Newsgroup: it.comp.programmare.win32
Titolo: pipe e passaggio di struct

Salve a tutti.
Avrrei la necessità di poter modificare i valori di una struct
che viene passata a diversi thread.
per farlo ho pensato di usare delle named pipe: un thread fa da server
e gli altri vanno periodicamente a leggere eventuali modifiche.
Sono andato allora a vedere gli esempi di msdn:
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/ipc/base/named_pipe_type_read_and_wait_modes.asp
Solo che le comunicazioni consistono solo in caratteri.
Esiste un modo per far passare attraverso pipe un'intera struct?
L'unica soluzione alternativa mi sembra sia quella di creare delle funzioni,
lato server e lato client, e passare pian piano tutti gli elementi della
struct,
ma la cosa sarebbe piuttosto macchinosa...
Se avete qualche consiglio in merito...
Molte grazie.
bye ;-)

Ma i thread fanno tutti parte del tuo programma? Se sě, perché mai usare
la pipe per il passaggio dei dati? (A parte il fatto che imho le mailslot
sono molto + semplici...)
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it


Vediamo se riesco a spiegarmi...
I thread sono tutti dello stesso programma:
il padre crea all'inizio un th che fa dei controlli su altri processi,
passandogli, fra le altre cose, una struct con dei parametri di
configurazione.
Poi il padre si mette in ascolto su una porta tcp,
e apre un nuovo thread per ogni connessione,
passando anche qui la stessa struct di prima.
Il mio intento č quello di cambiare i parametri di configurazione
del primo th creato, e del padre, attraverso una sessione tcp,
che quindi risiede su un altro thread...
L'alternativa, oltre a quella citata nell'altro post,
sarebbe quella di modificare il file di configurazione,
e farlo leggere al padre e al primo th periodicamente,
ma la cosa non mi piace molto, e si allontana da quello che realmente mi
serve
(il file di conf. deve contenere i parametri di "default")..
Per finire sinceramente non conosco la mailslot...
stavo iniziando a dare uno sguardo qui:
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/ipc/base/named_pipe_type_read_and_wait_modes.asp
si tratta anche in questo caso di messaggi di testo:
in che modo potrebbero agevolarmi rispetto alle pipe?
Chiedo scusa se mi sono dilungato tanto.
Grazie cmq per la risposta.
bye ;-)

 che quindi risiede su un altro thread...
<snip>
Non so se ho afferrato bene il tutto, ma a questo punto
potresti semplicemente creare un "watcher thread" da
avviare all'inizio, tale thread avrebbe come unica funzione
quella di stare in "wait" (waitfor....) su un mutex condiviso tra
tutti i vari threads, a questo punto nel momento in cui uno dei
thread secondari avesse la necessità di modificare alcuni
valori potrebbe semplicemente memorizzarli "da qualche
parte" ed accendere il mutex, questo a sua volta sveglierà
lo "watcher" che si prenderà carico delle modifiche del caso
Spero di essere stato chiaro .. e di aver capito il problema ..
Ciao

 lo "watcher" che si prenderà carico delle modifiche del caso
Appunto, quello che dicevo io era: a che servono le pipes? Si accede ai
dati normalmente, tenendo presente che sono protetti dal mutex (se ho ben
capito l'idea di ObiWan).


 ha scritto nel messaggio
news:2ijhsrF...@uni-berlin.de...

Sinceramente non conosco i mutex, per cui sono andato a documentarmi.
Da quanto ho capito, sono degli oggetti che permettono
di stabilire l'accesso esclusivo a determinate risorse condivise.
mi sembra interessante questo esempio:
http://phoenix.liunet.edu/~mdevi/win32/Mutex.htm
appena ho tempo faccio un po' di test.
molte graizie.
bye ;-)

 protetti dal mutex (se ho ben capito l'idea di ObiWan).
Si, hai capito, la mia era solo una precisazione; ovvio che
quanto sopra non è l'unico sistema anche se in linea di
massima l'idea sarebbe avere un paio di struct tipo
typedef struct {
    // ... altri dati per il child thread
    void            *lpServerData;            // altra roba del server
    HANDLE  hMutex;                           // mutex di protezione
    char            *dato01;                         // dati protetti dal
mutex
    DWORD     dato02;                        // ...
}
a questo punto creando il thread basterebbe passargli come
argomento il puntatore alla struttura di cui sopra per garantire
(previa acquisizione del mutex) l'accesso ai dati "shared"
un'altra soluzione sarebbe quella di usare la QueueUserAPC
per "svegliare" un thread che si occupi di processare le varie
richieste .. ma qui finiamo ... OT forse
Ciao