csma.c

code simulation csma/cd

#include <stdio.h>
#include <stdlib.h>
#include <math.h>


/* Definition des operations MAX et MIN  */

#ifndef  MAX
#define MAX(a, b)  (((a) > (b)) ? (a) : (b))
#endif

#ifndef  MIN
#define MIN(a, b)  (((a) < (b)) ? (a) : (b))
#endif



/* Delai moyen (repartition uniforme) entre deux requetes
  d'emission d'un message aperiodique  */

double  delai_moyen_entre_deux_messages_aperiodiques;



/* Tirage al閍toire entre 1 et max */

int tirage_aleatoire(double max)
{
        int j=(int) (max*rand()/(RAND_MAX+1.0));
	if(j<1)
		j=1;
	return j;
}



/* Informations stockees pour chaque station :  */

typedef struct station {

	/* Date intialement prevue pour l'emission du message
		en cours de transmission  */
	int date_initiale_emission_message;

	/* Date d'emission comprenant le temps d'attente
		aleatoire si le message 
		en cours de transmission est entre en collision
		avec un autre message */
	int date_emission_message;

	/* Memorise, pour le message en cours de 
		transmission, le nombre de collision qu'il
		a subi */
	int nb_collision;

	/* Numero de message en cours de transmission
		(ex : correspond au numero d'activation
		pour les messages periodiques)  */	
	int numero_de_message;
	
	} station;


/* Le bus est constitue de 3 stations */

struct station bus[3];


/* Simulation du temps */

int horloge=0;


/* Genere la date du message suivant a emettre */

void message_suivant(int i);



int main(int argc, char* argv[])
{

	FILE* csma;
	int i=0;
	int emetteur;



	/* Controle des parametres : le programme prend 
		en entree le delai moyen entre deux messages
		emis par la station 2. */
	if(argc!=2)
		{
		printf("utilisation : csma delai_moyen_entre_deux_messages_aperiodiques\n");
		exit(0);
		}	
	else	delai_moyen_entre_deux_messages_aperiodiques=atof(argv[1]);



	/* Ce fichier stocke le temps d'acces de chaque
	   message envoye par la station 0 */
	csma=fopen("csma.dta","w");
	if(csma==NULL)
		{
		printf("Pb ouverture fichier csma.dta\n");
		exit(0);
		}


	/* On initialise la date d'emission du premier
		message de chaque station */
	for(i=0;i<3;i++)
		{
		bus[i].date_initiale_emission_message=0;
		bus[i].date_emission_message=0;
		bus[i].numero_de_message=0;
		bus[i].nb_collision=0;
		}


	/* On boucle sur les 10000 premieres milli secondes */

	while(horloge<10000)
		{
		emetteur=-1;

		/* Application du protocole CSMA/CD */


			ACOMPLETER 

/*
	Vous devez ici simuler le protocole CSMA/CD, cad  :
		- tester pour chaque top d'horloge
			s'il y a collision (deux 
			stations que souhaitent emettre
			un message avec un 
			date_emission_message identique)
		- si collision il y a, generer, pour chaque
			message,  le temps 
			d'attente aleatoire conformement a 
			ce qui est decrit dans le sujet et
			mettre a jour la variable
			date_emission_message correspond.
			Vous disposez pour ce faire
			des fonctions C pow() (cf. man)
			et tirage_aleatoire (cf. ci-dessus).
		- dans le cas ou il n'y a pas de collision,
		 	la variable "emetteur" doit indiquer
			l'entre dans le tableau "bus" de la 	
			station elue
*/




		/* Si emetteur est different de -1, alors, on
			a emis un message : il n y a pas
			eut de collision donc */
		if(emetteur!=-1)
			{

			printf("Date %d  : Emission par station %d message numero %d\n",horloge,emetteur,bus[emetteur].numero_de_message);	

			/* On ecrit sur disque le temps d'acces obtenu
				si la station 0 a emis un message */ 
			if(emetteur==0)
				fprintf(csma,"%d %d\n",bus[0].numero_de_message,horloge-bus[0].date_initiale_emission_message); 


			/* On passe au message suivant */
			message_suivant(emetteur);
			}		


		horloge++;
	
		}


	fclose(csma);

	exit(0);


}




/* Les messages aperiodiques sont generes de facon
   aleatoire (loi uniforme de moyenne delai_moyen_entre_deux_messages_aperiodiques ) */ 

int prochain_message_aperiodique(void)
{
        int j= (int) ((2*delai_moyen_entre_deux_messages_aperiodiques)*rand()/(RAND_MAX+1.0));
        if(j<1)
                j=1;
        return j;
}


/* Une fois un message emis, on prepare l'emission du message 
suivant */
 
void message_suivant(int i)
{
	bus[i].numero_de_message++;

	switch (i)
		{

		/* Message periodique de periode 3 */
		case	0:	
			{
			bus[i].date_initiale_emission_message=
				MAX(horloge+1,bus[i].numero_de_message*3);
			break;
			}

		/* Message periodique de periode 9 */
		case	1:	
			{
			bus[i].date_initiale_emission_message=
				MAX(horloge+1,bus[i].numero_de_message*9);
			break;
			}

		/* Message aperiodique : date d'arrivee generee
			de facon aleatoire */
		case	2:	
			{
			bus[i].date_initiale_emission_message=horloge+prochain_message_aperiodique();
			break;
			}
		}

	bus[i].date_emission_message=bus[i].date_initiale_emission_message;
	bus[i].nb_collision=0;
}