pipe...cosa e quanto si può trasferire ad un figlio?

[Ricky]

ragazzi.....premettendo che sto uscendo pazzo co sto sistemi operativi....sapete come funziona bene una pipe??
cioè posso trasferire interi? posso trasferire più di un inf? se si mi aiutate facendo qualche esempio...ve ne sarei grato!!!:)

[Dun]

Beh, puoi trasferire tutto quello che vuoi anche struttture dati piuttosto complesse....sta a te pero' dirgli che stai scrivendo tot byte. In ogni caso il terzo argomento di solito e' un bel sizeof(struttura_dati_che_contiene_cio_che_le_vuoi mandare).


Se ben ricordo cmq hanno una loro dimensione...ovvero, hanno un buffer definito.....PIPE_BUF mi pare. Nel caso tu voglia trasferire piu' byte di PIPE_BUF non hai piu' garanzie di atomicita' nella read e nella write. :)

Cya!

[Ed_Bunker]

Originariamente inviato da Ricky
ragazzi.....premettendo che sto uscendo pazzo co sto sistemi operativi....sapete come funziona bene una pipe??
cioè posso trasferire interi? posso trasferire più di un inf? se si mi aiutate facendo qualche esempio...ve ne sarei grato!!!:)

Puoi scrivere su una pipe qualsiasi cosa sempre che tu ti mantenga al di sotto di una certa soglia oltre la quale la pipe non puo' piu' bufferizzare. Questa soglia e' ottenibile mediante delle macro predefinite o, ancor meglio, mediante una funzione di libreria (Non ricordo il nome...)
Due semplici e banali esempi;

se so che devo ricevere dalla pipe un intero:
...
int number;
read(fd0, &number, sizeof(int));
printf("Intero ricevuto: %d\n", *number);
...

se so che devo ricevere una stringa lunga non piu' di 100 byte:
...
int readed;
char * buffer = malloc(sizeof(char) * 100 +1);
readed = read(fd0, buffer, 100);
buffer[readed] = '\0';/*Aggiungo esplicitamente il carattere di terminazione alla stringa*/
printf("Stringa ricevuta: %s\n", buffer);
...

Bye

[akyra]

ricorda che le pipe anonime, solitamente, hanno dimensione fino a 5 K, mentre le FIFO (pipe con nome) hanno dimensione max fino a 40 K....

[Ricky]

la mia situazione è questa:
il processo padre deve mandare tramite una pipe un intero al figlio p1, vado a fare la write, quando ci passo un carattere tutto bene (facccio poi io la conversione) ma un intero niente...mi esce un numero tutto sballato!
faccio cosi,

/*padre*/
close(fd[0]);
write(fd[1],2,1) //* ho provato anche con una variabile

/*poi nel figlio*/

close(fd[1]);
read(fd[0],&temp,1);

poi un altra domanda...come faccio a passargli due interi....faccio un write e poi ne faccio un altro.....come posso fare?:muro: :muro: :muro: :muro:

[Ricky]

come non detto dovevo mettere il sizeof!!:) però il secondo problema rimane:muro: :muro:


ah un altra cosa...scusate sono proprio un rompiballe ma domani ho il laboratorio(ESAMEE)....
posso scrivere un intero in un file...? cioè con le funzioni read e write sul man ho trovato che posso passare char *buf...altrimenti so cazzi......devo fare la conversione?

[VegetaSSJ5]

ragazzi io ho provato a trasmettere una struttura attraverso una pipe ma mi dà errore in fase di compilazione.typedef struct messaggio {
int direzione;
char c;
} msg;
...

msg nuovo_msg;
nuovo_msg.direzione=OE;
nuovo_msg.c='s';
write (pipe, nuovo_msg, sizeof(msg));
mi dà errore in fase di compilazione...:cry:

[Ricky]

gaurda che devi scrivere nella parte della pipe in cui è prevista la scrittura...ovvero
se definisci

int fd[2]
pipe(fd)

fd[0] sarà la parte in lettura ed fd[1] la parte in scrittura
ogni volta prima di scrivere devi chiudere la parte che non ti serve e poi utilizzare il write:

close(fd[0]);
write(fd[1],"scrivonellepipe",15);


prova un pò!:)

[Mixmar]

Potresti trasformare l'int in una coppia di char... se non ricordo male, il char ha le dimensioni di un byte, mentre l'int (di solito) di 2... e a volte di 4, dipende dalla macchina e dal Sistema Operativo.

Sotto queste ipotesi, forse questo funziona:

/* Prima il MSB, poi il LSB */
int i=...

...

char a=(char)((i - (i % 256)) \ 256);
char b=(char)(i % 256);

E poi scrivi prima a e poi b sul file; quando li leggi, ripeti le operazioni al contrario.

Spero che funzioni... :confused:

[Ed_Bunker]

Originariamente inviato da akyra
ricorda che le pipe anonime, solitamente, hanno dimensione fino a 5 K, mentre le FIFO (pipe con nome) hanno dimensione max fino a 40 K....

Hai detto bene... Solitamente ! Meglio utilizzare la funzione apposita che ne restituisce la dimensione sulla piattaforma su cui si sta operando.

[Ed_Bunker]

Originariamente inviato da VegetaSSJ5
ragazzi io ho provato a trasmettere una struttura attraverso una pipe ma mi dà errore in fase di compilazione.typedef struct messaggio {
int direzione;
char c;
} msg;
...

msg nuovo_msg;
nuovo_msg.direzione=OE;
nuovo_msg.c='s';
write (pipe, nuovo_msg, sizeof(msg));
mi dà errore in fase di compilazione...:cry:

Alla write mica devi passare il nome della pipe. Sia che si tratti di pipe senza nome, sia che si tratti di pipe con nome, alla write(...) devi passare il descrittore del file restituito dalla open (In sola scrittura o in letturascrittura) sulla pipe.

[Ricky]

ma nessuno mi sa dire se posso scrivere due volte su una stessa pipe e leggere due volte da un altro processo.....cioè che faccio la apro la chiudo e la riapro...che posso fa?

[VegetaSSJ5]

Originariamente inviato da Ricky
gaurda che devi scrivere nella parte della pipe in cui è prevista la scrittura...ovvero
se definisci

int fd[2]
pipe(fd)

fd[0] sarà la parte in lettura ed fd[1] la parte in scrittura
ogni volta prima di scrivere devi chiudere la parte che non ti serve e poi utilizzare il write:

close(fd[0]);
write(fd[1],"scrivonellepipe",15);


prova un pò!:)
si questo è ovvio, solo che l'ho omesso nell'esempio che ho scritto prima.

[VegetaSSJ5]

Originariamente inviato da Ed_Bunker
Alla write mica devi passare il nome della pipe. Sia che si tratti di pipe senza nome, sia che si tratti di pipe con nome, alla write(...) devi passare il descrittore del file restituito dalla open (In sola scrittura o in letturascrittura) sulla pipe.
int miapipe[2];
if (pipe(miapipe)) printf("ERRORE");
close(miapipe[INPUT]);
write(miapipe.....)io intendevo questo. cmq il problema sta nel fatto che non mi trasmette la struttura come messaggio nella pipe. come posso fare per far trasmettere una struttura come messaggio??

[Ricky]

write (pipe, nuovo_msg, sizeof(msg));

prova con write (pipe, &nuovo_msg, sizeof(msg));

ma sicuro che si mette sizeof(msg) ? non si mette sizeof(messaggio)?

[Dun]

Originariamente inviato da Ricky
write (pipe, nuovo_msg, sizeof(msg));

prova con write (pipe, &nuovo_msg, sizeof(msg));

ma sicuro che si mette sizeof(msg) ? non si mette sizeof(messaggio)?


Esatto, alla write devi passare un puntatore -> quindi un indirizzo.

E' corretto anche sizeof(msg).

Nel caso nuovo_msg fosse stato un puntatore allora no, il sizeof ritorna la dimensione del puntatore che e' 4byte.

Potresti pero' fare un sizeof(*nuovo_msg). :)

EDIT: Avevo cannato a scrivere :)

[Ed_Bunker]

Originariamente inviato da VegetaSSJ5
int miapipe[2];
if (pipe(miapipe)) printf("ERRORE");
close(miapipe[INPUT]);
write(miapipe.....)io intendevo questo. cmq il problema sta nel fatto che non mi trasmette la struttura come messaggio nella pipe. come posso fare per far trasmettere una struttura come messaggio??

Azzo non me ne ero accorto... Devi mettere l'indirizzo.

write(miapipe, &nuovo_msg, sizeof(msg));

Prova...

[Ed_Bunker]

Originariamente inviato da Dun
Esatto, alla write devi passare un puntatore -> quindi un indirizzo.

E' corretto anche sizeof(msg).

Nel caso msg fosse stato un puntatore allora no, il sizeof ritorna la dimensione del puntatore che e' 4byte.

Potresti pero' fare un sizeof(*msg). :)

Scusa cosa vorrebbe dire fare '*msg' dato che msg e' un nuovo tipo (tipo puntatore secondo quello che hai suggerito) e non una variabile ?!
Magari si potrebbe fare, supposto msg un tipo puntatore:

msg myP;
...
...
write(..., myP, sizeof(*myP));
...

Anche se non sono sicuro che sia del tutto esatto mettere sizeof(*myP)...

[Dun]

Originariamente inviato da Ed_Bunker
Scusa cosa vorrebbe dire fare '*msg' dato che msg e' un nuovo tipo (tipo puntatore secondo quello che hai suggerito) e non una variabile ?!
Magari si potrebbe fare, supposto msg un tipo puntatore:

msg myP;
...
...
write(..., myP, sizeof(*myP));
...

Anche se non sono sicuro che sia del tutto esatto mettere sizeof(*myP)...

Scusa ho sbagliato a scrivere, adesso ho editato. Cmq a scanso di equivoci...

Ci sono due casi:
1) Dichiari la struttura dati nello stack: msg myP

In questo caso allora:
nella write utilizzi &myP
e come sizeof invece sizeof(myP) oppure sizeof(msg)

2) Dichiari la struttura nello heap attraverso un ptr e la allochi tramite malloc: msg *myP; myP = (msg *) malloc(sizeof(msg));

Qua invece nella write utilizzi myP
e come sizeof, sizeof(*myP) oppure sizeof(msg);


In effetti anche a me non tornava l' utilizzo del sizeof passandogli la dereferenziazione del puntatore ma l'ho appena provata sotto gcc 3.3.4 con flag -Wall quindi dovrebbe andare :)

[Ed_Bunker]

Mmm... dubbio derivante da memoria corta e sonno sovrastante... :)

/*Se ho una struttura siffatta:*/

struct myS{
char * a;
char * b;
int num;
}

/*dichiaro due variabili:*/

struct myS first;
struct myS second;
/*Inizializzo i campi di first*/
first.a = "NeutralMilkHotel";
first.b = "InTheAeroplaneOverTheSea";
first.num = 1998;
/*Adesso quelli di second*/
second.a = "MC5";
second.b = "Tonight";
second.num = 1970;
/*Facendo poi:*/
int L1 = sizeof(struct myS);
int L2 = sizeof(first);
int L3 = sizeof(second);

L1 == L2 == L3 ?!?!?

thks

[Dun]

Originariamente inviato da Ed_Bunker
Mmm... dubbio derivante da memoria corta e sonno sovrastante... :)

/*Se ho una struttura siffatta:*/

struct myS{
char * a;
char * b;
int num;
}

/*dichiaro due variabili:*/

struct myS first;
struct myS second;
/*Inizializzo i campi di first*/
first.a = "NeutralMilkHotel";
first.b = "InTheAeroplaneOverTheSea";
first.num = 1998;
/*Adesso quelli di second*/
second.a = "MC5";
second.b = "Tonight";
second.num = 1970;
/*Facendo poi:*/
int L1 = sizeof(struct myS);
int L2 = sizeof(first);
int L3 = sizeof(second);

L1 == L2 == L3 ?!?!?

thks


char * a;
char * b;


La risposta sta in queste due righe....

Le allocazioni gliele butti nello heap (anche se fatte in modo implicito tramite ptr = "ciao"; )

Questi sono due puntatori e la loro dimensione sara' sempre 4 byte (anche se e' un ptr a char puntera' ad un indirizzo di memoria a 32bit e quindi 4 byte).

[Ed_Bunker]

Originariamente inviato da Dun

char * a;
char * b;


La risposta sta in queste due righe....

Le allocazioni gliele butti nello heap (anche se fatte in modo implicito tramite ptr = "ciao"; )

Questi sono due puntatori e la loro dimensione sara' sempre 4 byte (anche se e' un ptr a char puntera' ad un indirizzo di memoria a 32bit e quindi 4 byte).

Adesso ci sono.
Grazie. ;)