Alcune domandine semplici sul C

[Cimmo]

Quindi tu dici cosi' (schematizzo molto)
con P indico il PADRE "listener"
con CH indico il figlio "chat" che si occupa della connessione in ingresso
con CN indico "connector" il figlio che tenta di connettersi

P: fork // creo CH
CH: attendo una connessione per me che viene accettata solo da mio padre P
P: fork //creo CN
CN: tento di connettermi, se ci riesco passo il socketfd a CH nel caso gli serva
P: aspetto connessioni da CN (non dal mio figlio, ma da CN generati da altre istanze del mio software) appena me ne arriva una passo il socketfd al mio CH di competenza.

Cosi' funziona in entrambi i casi?
caso 1) Mettiamo che il CN riesca a connettersi e deve condividere la connessione con il CH se gli passo il socketfd funzia?
caso 2) Il P riceve una connessione e la passa a CH e qui ok, poi magari serve anche al CN gli passa il socketfd funzia?

E questo che deve risultare...una sola connessione per 2 processi!

[cionci]

Io farei così :

Il processo princiapale può essere "Connector"...

Connector
fork
     Listener
     while(1) {
     aspetto sulla accept
     fork
          Chat
     }
while(1) {
Aspetto che venga richiesta una connessione
fork
     Chat
}

Ogni processo "Chat" ha il suo socket su cui fa una connessione bidirezionale...

[Cimmo]

No aspetta non ho capito: ogni processo Chat che cosa deve fare? Nel senso che io avevo gia' fatto una cosa simile facendo passare i socketfd, ma ilsensine mi ha detto che non funzia, perche' essendo processi differenti non hanno in comune i file descriptor...come devo fare di preciso? Come fanno i 2 processi chat a condividere la medesima connessione (qualora ne venga il bisogno?)

[cionci]

Allora usa i thread
Non una grande esperienza di programmazione multiprocesso in Linux...mi dispiace...

[Cimmo]

Originariamente inviato da ilsensine
[b]Non intendevo di far fare tutto a un padre, ma di creare i child solo quando servivano, per uno scopo ben preciso, e in maniera che possano essere autonomi una volta creati e inizializzati.
Cmq dovresti analizzare l'opportunità di usare i pthread al posto di processi distinti (è più facile l'ipc, non serve shm, semafori o altro).

Ciao ilsensine, non so se hai seguito il resto della vicenda...mi sembra di aver capito che o uso i pthread o m'attacco...come si usano? Sono facili come le fork? E soprattutto condivido veramente tutto? Se si' come faccio ad avere delle variabili autonome?

Thanx...

[ilsensine]

Originariamente inviato da Cimmo
[b]
Ciao ilsensine, non so se hai seguito il resto della vicenda...mi sembra di aver capito che o uso i pthread o m'attacco...come si usano? Sono facili come le fork? E soprattutto condivido veramente tutto? Se si' come faccio ad avere delle variabili autonome?

Thanx...

I pthread sono molto simili ai thread sotto windows. Hai mai lavorato con cose simili?

[Cimmo]

Originariamente inviato da ilsensine
[b]
I pthread sono molto simili ai thread sotto windows. Hai mai lavorato con cose simili?

No non ho mai lavorato, ho lavorato solo con le fork sotto Linux. Pero' devo imparare ed in fretta...saresti disponibile per una chiacchierata su IRC? Visto che secondo me il forum e' un po' lento per fare botte e risposte...se mi dici di no lo capisco...e' solo che sto facendo un progetto per l'universita' (faccio informatica a Bologna) e sono in ritardissimo...

ciao
Cimmo

[ilsensine]

Non è necessario, sono semplici da usare, ti faccio un breve howto:

Include necessario:
#include <pthread.h>
Quando compili, linka con le libpthread ( -lpthread )

Un thread è un "processo nel processo"; condivide tutta la memoria e i descrittori di file con gli altri thread; ogni thread ha uno stack ("stato") proprio.

Creazione di un thread:
pthread_t newthread;
pthread_create(&new_thread, NULL, funzione, parametro);

dove:
"funzione" è una funzione di prototipo void *(*) (void *); ad es.
void *funzione (void *parametro)
Questa funzione sarà l'inizio del nuovo thread.
parametro è un void * generico; è un parametro che puoi passare al thread, a tua discrezione.
Quando un thread termina deve chiamare
pthread_exit(void *retval)
dove retval è il parametro di "uscita" del thread, semmai ne hai bisogno.

Esempio:

#include <pthread.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>

void *th_fnc(void *data) {
  int param = (int) data;
  for(;;) {
    fprintf(stderr, "thread %d parametro %d\n", getpid(), param);
    sleep(1);
  }
}

int main() {
pthread_t unused;
pthread_create(&unused, NULL, th_fnc, (void *) 1);
pthread_create(&unused, NULL, th_fnc, (void *) 2);
for(;;) {
  fprintf(stderr, "thread padre\n");
  sleep(1);
}
return 0;
}

Nota che i thread possono accedere in maniera concorrente a _tutti_ i dati globali, funzioni o altro del processo corrente. Ovviamente ti servono delle strategie di lock, che fanno uso dei pthread_mutex:

Inizializzazione di un mutex:
pthread_mutex_t mutex;
pthread_mutex_init(&mutex, NULL);

Lock di un mutex (equivalente a "EnterCriticalSection" di Windows)
pthread_mutex_lock(&mutex)
oppure pthread_mutex_trylock(&mutex) per la forma non bloccante (altrimenti il lock è bloccante se il mutex è loccato da qualcun altro).

Unlock di un mutex:
pthread_mutex_unlock(&mutex);

Distruzione di un mutex non più necessario:
pthread_mutex_destroy(&mutex);

Esempio:

#include <pthread.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>

int x = 0;
int y = 0;
pthread_mutex_t mtx;

void *th_fnc(void *unused) {
  for(;;) {
    pthread_mutex_lock(&mtx);
/* Senza il lock, l'incremento di x e y non sarebbe atomico */
    x++;
    y++;
    fprintf(stderr, "thread %d (x,y)= (%d,%d)\n", getpid(), x, y);
    pthread_mutex_unlock(&mtx);
    sleep(1);
  }
}

int main() {
pthread_t unused;
pthread_mutex_init(&mtx, NULL);

pthread_create(&unused, NULL, th_fnc, NULL);
pthread_create(&unused, NULL, th_fnc, NULL);
for(;;) sleep(1);
return 0;
}

Le pagine man sono ricche di ulteriori dettagli, ma questo è il 90% di quello che ti serve.

[Cimmo]

Ok grazie e 1000, adesso mi metto al lavoro...ma una cosa sulle variabili:

1) se io dichiaro una variabile nel main (padre) poi creo dei thread questa e' condivisa da tutti? Nel senso il primo thread che la cambia, la cambia per tutti?
2) se voglio fare una variabile privata di un thread, mi basta dichiararla all'interno della sua funzione?

P.S.= Usando i thread ottimizzo automaticamente per i Pentium 4 HT
P.P.S.= C'e' un baco nel forum...anche se specifichi /CODE ti valuta lo stesso le faccine...sbagliato secondo me...infatti ha riconosciuto il punto e virgola e la parentesi della fine del for...

[ilsensine]

1) se io dichiaro una variabile nel main (padre) poi creo dei thread questa e' condivida da tutti? Nel senso il primo thread che la cambia, la cambia per tutti?

Certo, questo è il vantaggio principale dei thread. Sotto linux ciascun thread è implementato come un processo, ma un gruppo di thread condivide _tutta_ la memoria.

2) se voglio fare una variabile privata di un thread, mi basta dichiararla all'interno della sua funzione?

Certo, in quanto le variabili locali a una funzione finiscono nello stack, e ogni thread ha un suo stack.

P.S.= Usando i thread ottimizzo automaticamente per i Pentium 4 HT

...al pari di quanto ottimizzeresti con i processi.

P.P.S.= C'e' un baco nel forum...anche se specifichi /CODE ti valuta lo stesso le faccine...sbagliato secondo me...infatti ha riconosciuto il punto e virgola e la parentesi della fine del for...

Ho disabilitato le faccine

[Cimmo]

Originariamente inviato da ilsensine
[b]Non è necessario, sono semplici da usare, ti faccio un breve howto:

Creazione di un thread:
pthread_t newthread;
pthread_create(&new_thread, NULL, funzione, parametro);

Quando un thread termina deve chiamare
pthread_exit(void *retval)
dove retval è il parametro di "uscita" del thread, semmai ne hai bisogno.

Dunque ho gia' convertito tutto in thread, solo che prima di tutto, mi sembra che mettendo pthread_exit(NULL); nei thread da creare il programma non esegue contemporaneamente il suo codice e quello del figlio thread, ma esegue solo il codice del figlio e quando arriva al pthread_exit il software termina.
Se invece non lo metto mi dice in fase di compilazione:

host.c: In function `thReceive':
host.c:434: warning: control reaches end of non-void function
host.c: In function `thSend':
host.c:538: warning: control reaches end of non-void function

strano perche' le 2 funzioni sono void, dalle tue differiscono solo che prendono un puntatore ad un int come input.

Che cosa sta succedendo?

[ilsensine]

Dunque ho gia' convertito tutto in thread, solo che prima di tutto, mi sembra che mettendo pthread_exit(NULL); nei thread da creare il programma non esegue contemporaneamente il suo codice e quello del figlio thread, ma esegue solo il codice del figlio e quando arriva al pthread_exit il software termina.

?

Se invece non lo metto mi dice in fase di compilazione:

host.c: In function `thReceive':
host.c:434: warning: control reaches end of non-void function
host.c: In function `thSend':
host.c:538: warning: control reaches end of non-void function

strano perche' le 2 funzioni sono void, dalle tue differiscono solo che prendono un puntatore ad un int come input.

Non sono void, bensì void *.
Usando pthread_exit non ottieni quel warning in quanto è una funzione dichiarata con __attribute__ ((__noreturn__)) (in soldoni: non ritorna mai - ma questo è ovvio)

[Cimmo]

Originariamente inviato da ilsensine
[b]
?


Non sono void, bensì void *.
Usando pthread_exit non ottieni quel warning in quanto è una funzione dichiarata con __attribute__ ((__noreturn__)) (in soldoni: non ritorna mai - ma questo è ovvio)

Io li richiamo cosi':

for (i=0; i<=(TotHosts-1); i++)
{
         if ((i!=numHost) && (network[0][i].byteReceived>0))
                   pthread_create(&unused,NULL,thReceive(&i),NULL);

         if ((i!=numHost) && (i!=0) && (network[0][i].byteSent>0))
                   pthread_create(&unused,NULL,thSend(&i),NULL);
}

Ogni istanza esegue il primo if (cioe' il primo thread) non concorrentemente (non so perche') e finito il thread (arrivati a pthread_exit) termina l'istanza (tutto il programma)! E perche' le altre chiamate, il for ecc. non vengono eseguite?

[ilsensine]

...,thReceive(&i)...

Ehm...

Che è 'sta roba?

[Cimmo]

Originariamente inviato da ilsensine
[b]
Ehm...

Che è 'sta roba?

Per passargli l'indirizzo della variabile i ... non va bene?

[ilsensine]

Cerrrto che no
Così stai _chiamando_ la funzione
Riguardati bene il mio primo esempio; il parametro si passa così:

pthread_create(&unused,NULL,thReceive,(void *) i);

[ilsensine]

Nota inoltre che devi passare il valore di i, non il suo indirizzo, altrimenti ora che il thread legge il valore...il ciclo for l'ha già modificato!

[Cimmo]

Originariamente inviato da ilsensine
[b]Cerrrto che no
Così stai _chiamando_ la funzione
Riguardati bene il mio primo esempio; il parametro si passa così:
pthread_create(&unused,NULL,thReceive,(void *) i);

Ok l'ho chiamata come hai detto tu: poi nel codice della funzione ho messo:
int i=(int) toHost;

e la funzione l'ho dichiarata cosi': void *thSend(void *toHost)

va bene?

[ilsensine]

Sì, è corretto.
Nota che se devi passare più di un parametro al thread, la procedura comune è allocare dinamicamente una struttura apposita, e passare il puntatore al thread. Sarà compito del thread, quando termina, deallocare la struttura.

[Cimmo]

Un'altra cosa:
per le risorse in comune: devo gestire la mutua esclusione solo quando la risorsa viene modificata, se una risorsa non viene modificata e viene soltanto letta non ha senso che metta la mutua esclusione giusto?