Esperimenti con message passing in C - Revision history

FedericoB: /* Soluzione senza gestore delle bacchette */ Corretto typo.

2016-12-11T08:15:53Z

Soluzione senza gestore delle bacchette: Corretto typo.

FedericoB: /* Dining philosophers con message passing */ Aggiunta soluzione senza gestore delle bacchette.

2016-12-10T21:06:34Z

Dining philosophers con message passing: Aggiunta soluzione senza gestore delle bacchette.

FedericoB: Aggiunta proposta astratta del problema dei filosofi.

2016-12-09T10:31:36Z

Aggiunta proposta astratta del problema dei filosofi.

Renzo at 10:00, 9 December 2016

2016-12-09T10:00:45Z

Renzo: /* aggiornamento Dec. 6 2016 */

2016-12-06T07:26:59Z

aggiornamento Dec. 6 2016

Renzo at 07:26, 6 December 2016

2016-12-06T07:26:32Z

Renzo at 18:26, 4 December 2016

2016-12-04T18:26:44Z

Renzo at 18:23, 4 December 2016

2016-12-04T18:23:18Z

Renzo: Created page with "Ho messo a vostra disposizione alcuni sorgenti che implementano in C le astrazioni di message passing sincrono, asincrono e completamente asincrono come le abbiamo viste (o v..."

2016-12-04T18:22:31Z

Created page with "Ho messo a vostra disposizione alcuni sorgenti che implementano in C le astrazioni di message passing sincrono, asincrono e completamente asincrono come le abbiamo viste (o v..."

New page

Ho messo a vostra disposizione alcuni sorgenti che implementano in C le astrazioni di message passing sincrono, asincrono e completamente asincrono
come le abbiamo viste (o vedremo presto) a lezione.

Ho messo il materiale in [http://www.cs.unibo.it/~renzo/so/tools/mp.tgz questo file].

La directory comprende:
* un Makefile
* suspend.[ch] è il modulo che implementa la sospensione e riattivazione dei pthread (usando il segnale SIGUSR1).
* msg.[ch] modulo di implementazione dei paradigmi di message passing.
* sender.c receiver.c: esempi di processi che si scambiano un messaggio (sender manda a receiver che risponde).

----

IL file msg.h spiega come usare i servizi forniti da questi sorgenti.

Per iniziare occorre dare il nome al processo durante l'inizializzazione del servizio:
<syntaxhighlight lang=C>
void async_msg_init(char *procname);
void sync_msg_init(char *procname);
void nb_msg_init(char *procname);
</syntaxhighlight>

IL tipo di servizio (sincrono, asincrono o completamente asincrono) viene deciso al momento della inizializzazione e non puo' piu' essere cambiato.

Per spedire un messaggio basta indicare il nome del destinatario, il buffer contenente il messaggio e la lunghezza in byte del messaggio.
<syntaxhighlight lang=C>
ssize_t msg_send(char *dest, const void *buf, size_t len);
</syntaxhighlight>
L'interfaccia e' simile alla system call "write" ma al posto del file descriptor c'e' il nome del destinatario.
E' possibile inviar messaggi vuoti (di solito servono per indicare un acknowledgement.
Al momento della spedizione il processo destinatario deve esistere, altrimenti la funzione ritorna errore.
In caso di successo la funzione restituisce ilnumero di byte inviati, -1 un caso di errore.

Per ricevere un messaggio si usa la funzione msg_receive:
<syntaxhighlight lang=C>
ssize_t msg_recv(char *sender, void *buf, size_t len);
</syntaxhighlight>
Il campo sender può essere:
* una stringa: in questo caso viene ricevuto il primo messaggio spedito dal mittente indicato
* NULL: viene ricevuto il primo messaggio ricevuto qualsiasi ne sia stato il mittente
* una variabile di tipo ''msg_procname'' con il primo byte zero (una stringa vuota di dimensione adeguata): viene ricevuto il primo messaggio ricevuto qualsiasi ne sia stato il mittente e il nome del mittente viene salvato nella variabile sender.

@@ Line 68: / Line 68: @@
 ===Soluzione senza gestore delle bacchette===
 In questa soluzione non c'è un gestore delle bacchette a cui richiederne l'uso ma i filosofi si scambiano direttamente messaggi per accordarsi. <br>
-Essendo la libreria del message passing non attualmente thread safe ho implementato la soluzione utilizzando un processo per ogni filoso. <br>
+Essendo la libreria del message passing non attualmente thread safe ho implementato la soluzione utilizzando un processo per ogni filosofo. <br>
 C'è un programma chiamato ''startPhilos'' che tramite fork() e exec() esegue i filosofi. StartPhilos assegna anche le bacchette iniziali tramite parametri, io ho seguito la regola che viene assegnata la bacchetta sempre al filosofo con id minore tra i 2 filosofi che potrebbero avere quella bacchetta. In realtà qualsiasi ordine è accettabile, a parte quello in cui si impone una situazione di deadlock. <br>
 Ogni stick ha 3 stati: without(il filosofo ha bisogno della bacchetta), clean e dirty. Se a un filosofo manca una bacchetta la richiede al vicino.<br>

@@ Line 65: / Line 65: @@
 ==Dining philosophers con message passing==
---[[User:FedericoB|FedericoB]] ([[User talk:FedericoB|talk]]) 11:31, 9 December 2016 (CET) Sto cercando di implementarlo senza un agente centrale che sincronizza ma con solo i filosofi che si scambiano messaggi. Riporto la soluzione con i soli passaggi logici.
 <syntaxhighlight lang=C>
 while (1) {
          //think
-         //se mentre pensavi il filosofo alla tua destra o alla tua sinistra ti hanno chiesto le bacchette allora concedile
+        usleep(random() % 2000000);
-         //chiedi le bacchette al filosofo alla tua destra e alla tua sinistra e aspetta finché non ti rispondono tutti e due
+        //request right stick if the philosopher doesn't have it
-         //eating
+        if (rightStick == without) {
-         //guarda se ti hanno chiesto le bacchette mentre mangiavi e concedile.
+            msg_send(rightPhilo, "request", 8);
-        // Se non ti hanno ancora chiesto le bacchette aspetta finché non te le chiedono.
+     }
 </syntaxhighlight>
---[[User:FedericoB|FedericoB]] ([[User talk:FedericoB|talk]]) 11:31, 9 December 2016 (CET) Ho il problema che dopo aver pensato un filosofo non trova mai richieste per le bacchette, quindi non le concede mai e tutti vanno in deadlock.
+Potete trovare un archivio con i sorgenti completi e commentati e makefile [http://federico.bertani.web.cs.unibo.it/chattingPhilosophers.tar.gz qui]. <br>

← Older revision		Revision as of 10:31, 9 December 2016
Line 63:		Line 63:

	Ho aggiunto [http://www.cs.unibo.it/~renzo/so/tools/mp.extra.tgz questo file] che contiene gli esempi di implementazione di message passing asincrono dato quello sincrono (con server) e message passing completamente asincrono dato quello sincrono.		Ho aggiunto [http://www.cs.unibo.it/~renzo/so/tools/mp.extra.tgz questo file] che contiene gli esempi di implementazione di message passing asincrono dato quello sincrono (con server) e message passing completamente asincrono dato quello sincrono.
		+
		+	==Dining philosophers con message passing==
		+	--[[User:FedericoB\|FedericoB]] ([[User talk:FedericoB\|talk]]) 11:31, 9 December 2016 (CET) Sto cercando di implementarlo senza un agente centrale che sincronizza ma con solo i filosofi che si scambiano messaggi. Riporto la soluzione con i soli passaggi logici.
		+	<syntaxhighlight lang=C>
		+
		+	#include <stdint.h>
		+	#include <zconf.h>
		+	#include <stdlib.h>
		+	#include <pthread.h>
		+	#include <msg.h>
		+	#include <memory.h>
		+
		+	#define MPTYPE np
		+
		+	#define __msg_init(T, X) T ## _msg_init(X)
		+	#define _msg_init(T, X) __msg_init(T,X)
		+	#define msg_init(X) _msg_init(MPTYPE, X)
		+
		+	void philo(void arg) {
		+	//inizializza message passing
		+	//utilizza il mio indice di filosofo come nome
		+	//fai una receive in modo che il thread che gestisce la coda dei messaggi
		+	//si segni che stai aspettando messaggi dal filosofo alla tua destra e alla tua sinistra
		+	while (1) {
		+	//think
		+	//se mentre pensavi il filosofo alla tua destra o alla tua sinistra ti hanno chiesto le bacchette allora concedile
		+	//chiedi le bacchette al filosofo alla tua destra e alla tua sinistra e aspetta finché non ti rispondono tutti e due
		+	//eating
		+	//guarda se ti hanno chiesto le bacchette mentre mangiavi e concedile.
		+	// Se non ti hanno ancora chiesto le bacchette aspetta finché non te le chiedono.
		+	}
		+	}
		+
		+	int main(int argc, char *argv[]) {
		+	uintptr_t i;
		+	pthread_t philo_thread[5];
		+	srandom(time(NULL));
		+	for (i = 0; i < 5; i++)
		+	pthread_create(&philo_thread[i], NULL, philo, (void *) i);
		+	for (i = 0; i < 5; i++)
		+	pthread_join(philo_thread[i], NULL);
		+	}
		+	</syntaxhighlight>
		+	--[[User:FedericoB\|FedericoB]] ([[User talk:FedericoB\|talk]]) 11:31, 9 December 2016 (CET) Ho il problema che dopo aver pensato un filosofo non trova mai richieste per le bacchette, quindi non le concede mai e tutti vanno in deadlock.

← Older revision		Revision as of 10:00, 9 December 2016
Line 59:		Line 59:
	</pre>		</pre>
	generano gli eseguibili di esempio per i vari paradigmi di message passing. Lanciando da due shell diverse (e.g. due finestre terminale) prima ''receiver'' in una e poi ''sender'' nell'altra si potranno osservare le stampe dei due programmi.		generano gli eseguibili di esempio per i vari paradigmi di message passing. Lanciando da due shell diverse (e.g. due finestre terminale) prima ''receiver'' in una e poi ''sender'' nell'altra si potranno osservare le stampe dei due programmi.
		+
		+	=== aggiornamento Dec. 9 2016 ===
		+
		+	Ho aggiunto [http://www.cs.unibo.it/~renzo/so/tools/mp.extra.tgz questo file] che contiene gli esempi di implementazione di message passing asincrono dato quello sincrono (con server) e message passing completamente asincrono dato quello sincrono.

@@ Line 53: / Line 53: @@
 Il makefile ha ora un parametro opzionale per la compilazione dei test/tutorial "receiver" e "sender".
-<syntaxhighlight lang=sh>
+<pre>
 make clean; make MPTYPE=async
 make clean; make MPTYPE=sync
 make clean; make MPTYPE=nb
-</syntaxhighlight>
+</pre>
 generano gli eseguibili di esempio per i vari paradigmi di message passing. Lanciando da due shell diverse (e.g. due finestre terminale) prima ''receiver'' in una e poi ''sender'' nell'altra si potranno osservare le stampe dei due programmi.

@@ Line 1: / Line 1: @@
-Ho messo a vostra disposizione alcuni sorgenti che implementano in C le astrazioni di message passing sincrono, asincrono e completamente asincrono
+Ho messo a vostra disposizione alcuni sorgenti che implementano in C le astrazioni di message passing sincrono, asincrono e completamente asincrono come le abbiamo viste (o vedremo presto) a lezione.
 Ho messo il materiale in [http://www.cs.unibo.it/~renzo/so/tools/mp.tgz questo file].
@@ Line 40: / Line 39: @@
 * NULL: viene consegnato il primo messaggio ricevuto qualsiasi ne sia stato il mittente
 * una variabile di tipo ''msg_procname'' con il primo byte zero (una stringa vuota di dimensione adeguata): viene consegnato il primo messaggio ricevuto qualsiasi ne sia stato il mittente e il nome del mittente viene salvato nella variabile sender.

@@ Line 28: / Line 28: @@
 </syntaxhighlight>
 L'interfaccia e' simile alla system call "write" ma al posto del file descriptor c'e' il nome del destinatario.
-E' possibile inviar messaggi vuoti (di solito servono per indicare un acknowledgement.
+E' possibile inviare messaggi vuoti (di solito servono per indicare un acknowledgement.
 Al momento della spedizione il processo destinatario deve esistere, altrimenti la funzione ritorna errore.
 In caso di successo la funzione restituisce ilnumero di byte inviati, -1 un caso di errore.

@@ Line 38: / Line 38: @@
 Il campo sender pu&ograve; essere:
 * una stringa: in questo caso viene ricevuto il primo messaggio spedito dal mittente indicato
-* NULL: viene ricevuto il primo messaggio ricevuto qualsiasi ne sia stato il mittente
+* NULL: viene consegnato il primo messaggio ricevuto qualsiasi ne sia stato il mittente
-* una variabile di tipo ''msg_procname'' con il primo byte zero (una stringa vuota di dimensione adeguata): viene ricevuto il primo messaggio ricevuto qualsiasi ne sia stato il mittente e il nome del mittente viene salvato nella variabile sender.
+* una variabile di tipo ''msg_procname'' con il primo byte zero (una stringa vuota di dimensione adeguata): viene consegnato il primo messaggio ricevuto qualsiasi ne sia stato il mittente e il nome del mittente viene salvato nella variabile sender.