/*
 *------------------------------------------------------------------------
 * clkinit - initialize the clock and sleep queue (called at startup)
 *------------------------------------------------------------------------
 */
int
clkinit(void)
{
	int clkint();

	set_evec(IRQBASE, clkint);

	clkruns = 1;
	clockq = newqueue();
	preempt = QUANTUM;		/* initial time quantum		*/
	
	compute_delay();

	/*  set to: timer 0, 16-bit counter, rate generator mode,
		counter is binary */
	outb(CLKCNTL, 0x34);
	/* must write LSB first, then MSB */
	outb(CLOCK0, (char)DIVIDER);
	outb(CLOCK0, DIVIDER>>8);

	return OK;
}
Beispiel #2
0
/**
  * @brief Gestisce la lettura dei pacchetti UDP provenienti dal Monitor.
  * @return void.
 */
void lettura_pkt_monitor(void)
{
	uint32_t buf[ (65536/sizeof(uint32_t)) ];
	struct sockaddr_in From;
	unsigned int Fromlen;
	int ris;

	memset(&From,0,sizeof(From));
	Fromlen=sizeof(struct sockaddr_in);
	ris = recvfrom ( monitordatafd, (char*)buf, (int)65536, 0, (struct sockaddr*)&From, &Fromlen);
	if (ris<0)
	{
		if(errno!=EINTR) 
		{	
			fprintf(stderr,"recvfrom() failed, Error: %d \"%s\"\n", errno,strerror(errno));
			fprintf(stderr,"ma non ho chiuso  il socket");
		}
	}
	else
	{
		int ris2;
		long int msecdelay;
		uint32_t idletto;
		uint16_t portfromfixed;

		/* Salva la porta da cui arrivano i pacchetti del Fixed */
		portfromfixed = ntohs(From.sin_port);
		
		/* Se legge un ping calcola il suo delay e lo imposta 0 come id */
		if(ris == SIZE_PING)
		{
			idletto=0;
			msecdelay=compute_delay_ping(buf);
		}

		/* Altrimenti lo gestisce come un normale pacchetto */
		else
		{
			idletto=buf[0];
			msecdelay=compute_delay(buf);
		}

		/* Se sono pacchetti normali e non ping, li inoltra all'applicazione */
		if(ris != SIZE_PING)
		{
			ris2=Sendn(appmobilefd,(char*)buf,ris);
			if(ris2!=ris) { fprintf(stderr,"recv from appmobile failed, received %d: ", ris); exit(9); }
		}

		/* Se arriva un pacchetto in ritardo e la porta da cui arriva è la stessa da cui invia, la cambia perché LENTA */
		if((msecdelay > PKT_IN_TIME) && (portfromfixed == cfgPorte[index]))
		{
			index=(index+1)%numporte;
		}
		/* Altrimenti se arriva un pacchetto in orario su una porta differente, si sincronizza su quella porta */
		else if((msecdelay <= PKT_IN_TIME) && (portfromfixed != cfgPorte[index]))
		{
			index=trova_porta(portfromfixed, cfgPorte, index, numporte);
		}
	}
}
Beispiel #3
0
int main(int argc, char *argv[])
{
	uint16_t portLBfixed;
	int ris, LBfixedfd;
	pthread_t th;
	int primoricevuto=0;
	int tipogenerazionepkt;

	if(argc==1) { 
		printf ("uso i parametri di default \n%s\n", PARAMETRIDEFAULT );
		portLBfixed = 11001;
		tipogenerazionepkt=2;
	}
	else if(argc!=3) { printf ("necessari 2 parametri\n"); usage(); exit(1);  }
	else { /* leggo parametri da linea di comando */
		portLBfixed = atoi(argv[1]);
		tipogenerazionepkt=atoi(argv[2]);
	}

	if ((signal (SIGHUP, sig_close)) == SIG_ERR) { perror("signal (SIGHUP) failed: "); EExit(2); }
	if ((signal (SIGINT, sig_close)) == SIG_ERR) { perror("signal (SIGINT) failed: "); EExit(2); }
	if ((signal (SIGTERM, sig_close)) == SIG_ERR) { perror("signal (SIGTERM) failed: "); EExit(2); }

	init_random();
	ris=socketpair(AF_UNIX,SOCK_STREAM,0,fds);
	if (ris < 0) {	perror("socketpair fds0 failed: ");	EExit(1); }
	/*
	ris=SetsockoptTCPNODELAY(fds[0],1); if (!ris)  EExit(5);
	ris=SetsockoptTCPNODELAY(fds[1],1); if (!ris)  EExit(5);
	*/

	/* mi connetto al LBfixed */
	ris=TCP_setup_connection(&LBfixedfd, "127.0.0.1", portLBfixed,  300000, 300000, 1);
	if(!ris) {	printf ("TCP_setup_connection() failed\n"); EExit(1); }
	f=fopen("delayfixed.txt","wt");
	if(f==NULL) { perror("fopen failed"); EExit(1); }

	/* inizializzo il sistema di controllo dei pkt ricevuti e/o duplicati */ 
	init_checkrecvFixed();
	init_checkrecvFixedDelay();

	FD_ZERO(&all);
	FD_SET(LBfixedfd,&all);
	maxfd=LBfixedfd;
	FD_SET(fds[0],&all);
	if(maxfd<fds[0]) maxfd=fds[0];

	for(;;)
	{
		struct timeval timeout;
		long int msecdelay;

		do {
			rdset=all;
			timeout.tv_sec=10;
			timeout.tv_usec=0;
			ris=select(maxfd+1,&rdset,NULL,NULL,&timeout);
			/* ris=select(maxfd+1,&rdset,NULL,NULL,&timeout); */
		} while( (ris<0) && (errno==EINTR) );
		if(ris<0) {
			perror("select failed: ");
			EExit(1);
		}

		/* se arriva qualcosa dalla connessione TCP con LBfixed, leggo!!!! */
		if( FD_ISSET(LBfixedfd,&rdset) )
		{
			uint32_t buf[PKTSIZE], idletto; int ris;

#ifdef VICDEBUG
			fprintf(stderr,"in arrivo qualcosa dalla connessione TCP del LBfixed:\n");
#endif
			/* ris=recv(LBfixedfd,(char*)buf,PKTSIZE,MSG_DONTWAIT); */
			/* ris=Readn(LBfixedfd,(char*)buf,PKTSIZE); */
			ris=Readn(LBfixedfd,(char*)buf,sizeof(buf));
			/*if(ris!=PKTSIZE) { fprintf(stderr,"recv from LBfixed failed, received %d: ", ris); EExit(9); }*/
			if(ris!=sizeof(buf)) { fprintf(stderr,"recv from LBfixed failed, received %d: ", ris); EExit(9); }
			idletto=buf[0];
			/* printf("ricevuto pkt id %u\n",idletto); */
			msecdelay=compute_delay(buf);
			if( check_pkt_recv_at_Fixed(idletto) == 1 ) /* pacchetto duplicato */
			{
				printf("ricevuto pkt duplicato id %d delay %ld msec \n",idletto, msecdelay);
				numduplicati++;
			}
			else
			{
				/* memorizzo di avere ricevuto il pkt */
				set_pkt_recv_at_Fixed(idletto);
				SetpktrecvFixedDelay(idletto,msecdelay);
#ifdef OUTPUT_MEDIO
				printf("ricevuto pkt id %lu delay %ld msec \n",idletto, msecdelay);
#endif
				if(primoricevuto==0) {
					pkt_generator_parameters params;
					primoricevuto=1;
					idlastrecv=idletto;
					/* faccio partire il pthread pkt_generator per attivare la generazione di pacchetti */
					params.tipogenerazionepkt=tipogenerazionepkt;
					params.fd=fds[1];
					ris = pthread_create (&th, NULL, pkt_generator, (void*)&params );
					if (ris){
						printf("ERROR; return code from pthread_create() is %d\n",ris);
						EExit(-1);
					}
				}
				else if(idletto>idlastrecv) {
					idlastrecv=idletto;
				}
				if(msecdelay>150) {
					numritardi++;
					printf("%d : delay msec %ld  TEMPO SUPERATO\n", idletto, msecdelay);
				}
				else {
					numok++;
					printf("%d : delay msec %ld\n", idletto, msecdelay);
				}
				/* save_delay(f,buf); */
			}
		}
		else
		{
			if( FD_ISSET(fds[0],&rdset) )
			{
				char ch;
				/* IL BUG E' QUI: E' STATO USATO UN VETTORE DI UINT32 PER CREARE IL PACCHETTO QUANDO SI SAREBBE DOVUTO USARE UN */
				/* VETTORE DI CARATTERI (char buf[PKTSIZE]) DATO CHE : */
				/* sizeof(buf) = 400 , con uint32_t buf[PKTSIZE] */
				/* sizeof(buf) = 100 , con char buf[PKTSIZE] */
				/* ERGO LA RICEZIONE E L'INVIO DEI PACCHETTI VA FATTA CON 400 DI DIMENSIONE E NON PKTSIZE, CIOÈ 100 */
				uint32_t buf[PKTSIZE];
				struct timeval sent;

				do {
					ris=recv(fds[0],&ch,1,0);
				} while( (ris<0) && (errno==EINTR) );
				if(ris<0) {
					perror("Appfixed - recv from scheduler failed: ");
					sleep(1);
					EExit(1);
				}
				/* spedisco i pkt */
				/*memset((char*)buf,0,PKTSIZE);*/
				memset((char*)buf,0,sizeof(buf));
				buf[0]=idmsg;
				gettimeofday(&sent,NULL);
				memcpy( (char*)&(buf[1]), (char*)&sent, sizeof(struct timeval) );

				/*
					fprintf(stderr,"pkt %u sent %ld sec %ld usec\n", idmsg, sent.tv_sec, sent.tv_usec );
				*/

				/*ris=Sendn(LBfixedfd, (char*)buf, PKTSIZE  );*/
				ris=Sendn(LBfixedfd, (char*)buf, sizeof(buf) );
				/*if(ris!=PKTSIZE) {*/
				if(ris!=sizeof(buf)) {
					fprintf(stderr,"Appfixed - Sendn failed   ris %d  TERMINO\n", ris);
					sleep(1);
					EExit(1);
				}
#ifdef OUTPUT_MEDIO
				fprintf(stderr,"pkt %u sent %dB\n", idmsg, ris);
#endif
				idmsg++;

			}
		}

	} /* fine for ;; */
	return(0);
}
Beispiel #4
0
void compute_estimation(aodv_neigh *tmp_neigh) {

	int recv_delay;
	//Nominal rate computation
	//Add last own transmission delay measured by our neighbour
	tmp_neigh->ett.count_rcv++;
	
	if (tmp_neigh->ett.count_rcv == tmp_neigh->ett.ett_window) { //Let's compute the estimation!
		recv_delay = compute_delay(tmp_neigh);
		
		if (recv_delay == 0 && tmp_neigh->ett.ett_window == ETT_PROBES_MAX) {
			if (tmp_neigh->ett.reset) { //Second consectutive round without an estimation!
#ifdef DEBUG
				printk(
						"Capacity Estimation with %s is not possible - Second: Resetting\n",
						inet_ntoa(tmp_neigh->ip));
#endif
				reset_ett(tmp_neigh);

			} else { //First round without an estimation!
#ifdef DEBUG
				printk(
						"Capacity Estimation with %s is not possible - First: Using last measured values\n",
						inet_ntoa(tmp_neigh->ip));
#endif
				//lets start a new measurements round
				delay_vector_init(&(tmp_neigh->ett.recv_delays[0]));
				tmp_neigh->ett.count_rcv = 0;
				tmp_neigh->ett.ett_window = ETT_PROBES_MIN;
				tmp_neigh->ett.reset = 1;

			}
			send_ett_info(tmp_neigh, tmp_neigh->send_rate, FALSE);
			return;
		}

		if (recv_delay == 0) {
			//Increase the size of the estimation window
			tmp_neigh->ett.ett_window += 2; //lets do two more measurements
			if (tmp_neigh->ett.ett_window > ETT_PROBES_MAX)
				tmp_neigh->ett.ett_window=ETT_PROBES_MAX;
			return;
		}

		if (recv_delay == DEFAULT_ETT_METRIC) {
#ifdef DEBUG
			printk(
					"%s does not receive my ETT_PROBES: Capacity Estimation is not possible - Resetting ETT...\n",
					inet_ntoa(tmp_neigh->ip));
#endif
			reset_ett(tmp_neigh);
			return;
		}
		//lets start a new measurement round
		delay_vector_init(&(tmp_neigh->ett.recv_delays[0]));
		tmp_neigh->ett.count_rcv = 0;
		tmp_neigh->ett.ett_window = ETT_PROBES_MIN;
		tmp_neigh->ett.reset = 0;
		tmp_neigh->send_rate = compute_rate(recv_delay);
		send_ett_info(tmp_neigh, tmp_neigh->send_rate, FALSE);
	}

}