restoration_sink.pr.c

实验室前辈用OPNET做的光突发交换网络的仿真实验

				/*				printf("fail = %d\n", fail[i][j]);
								printf("succ = %d\n", succ[i][j]);
								printf("loss_rate = %f\n", loss_rate[i][j]);
								printf("loss = %f\n", loss);
								printf("sum_hop = %d\n", sum_hop[i][j]);
								printf("b_sum_hop = %d\n", b_sum_hop[i][j]);
								printf("average_hop = %f\n", average_hop[i][j]);
								printf("b_average_hop = %f\n", b_average_hop[i][j]);
								printf("sum_delay = %f\n", sum_delay[i][j]);
								printf("b_sum_delay =%f\n", b_sum_delay[i][j]);
								printf("average_delay = %f\n", average_delay[i][j]);
								printf("b_average_delay = %f\n", b_average_delay[i][j]);
								if(burst_time[i][j] !=0) printf("burst_time = %f\n", burst_time[i][j]);
				*/
							}
						}
						total_gen_bcp = total_gen_bcp + gen_bcp[i];
						total_all_succ = total_all_succ + all_succ[i];
				//		printf("gen = %d succ = %d\n", gen_bcp[i], all_succ[i]);
				//		printf("succ = %d fail = %d\n", s_bcp, f_bcp);
				//		getchar();
				
					}
				
					loss = (double) loss / 16;
					total_average_hop = (double) total_average_hop /16;
					b_total_average_hop = (double) b_total_average_hop / backup_count;
					total_average_delay = (double) total_average_delay / 16;
					b_total_average_delay = (double) b_total_average_delay / backup_count;
					
					utilization = (double) utilization / (4*WAVE_NUM*sim_time);
					throughput = (double) total_all_succ / total_gen_bcp;
					
					back_average_delay = (double) back_sum_delay/back_succ;
					back_average_hop = (double) back_sum_hop/back_succ;
					back_throughput = (double) back_succ/gen_backup_bcp;
					back_loss = (double) (back_fail+back_fis_fail)/(gen_backup_bcp+back_fis_fail);
					back_utilization = (double) back_burst_time/(back_average_hop*WAVE_NUM*1);
					
					/*
					printf("back_average_delay = %f\n", back_average_delay);
					printf("back_average_hop = %f\n", back_average_hop);
					printf("back_succ = %d\n", back_succ);
					printf("back_fail = %d\n", back_fail);
					printf("back_fis_fail = %d\n", back_fis_fail);
					printf("gen_backup_bcp = %d\n", gen_backup_bcp);
					printf("back_throughput = %f\n", back_throughput);
					printf("back_loss = %f\n", back_loss);
					printf("back_burst_time = %f\n", back_burst_time);
					printf("back_utilization = %f\n", back_utilization);
					
					//getchar();
					
					
					printf("LOSS = %f\n", loss);
					printf("FIS_LOSS = %d\n", fis_loss);
					printf("TOTAL_AVERAGE_HOP = %f\n", total_average_hop);
					printf("B_TOTAL_AVERAGE_HOP = %f\n", b_total_average_hop);
					printf("TOTAL_AVERAGE_DELAY = %f\n", total_average_delay);
					printf("B_TOTAL_AVERAGE_DELAY = %f\n", b_total_average_delay);
					printf("utilization = %f\n", utilization);
					printf("throughput = %f\n", throughput);
					*/
					//***************************************************************************
					strcpy(f_name,"d:/data/bak-");
					strcat(f_name, file_name);
						   
					if((fp = fopen(f_name, "w")) == NULL)
						{
						printf("cannot open file \n");
						exit(1);
						}
					fprintf(fp, "%s\t", f_name);
					fprintf(fp, "b_average_hop:\t %f\t", back_average_hop);
					fprintf(fp, "b_average delay:\t%f\t", back_average_delay);
					fprintf(fp, "b_loss:\t%f\t", back_loss);
					fprintf(fp, "b_throughput:\t%f\t", back_throughput);
					fprintf(fp, "all_utilization:\t%f\t", utilization);
					fprintf(fp, "b_utilization:\t%f\t", back_utilization);
					fprintf(fp, "back_succ:\t%d\t", back_succ);
					fprintf(fp, "back_fail:\t%d\t", back_fail);
					fprintf(fp, "back_fis_fail:\t%d\t", back_fis_fail);
					fprintf(fp, "gen_backup_bcp:\t%d\n", gen_backup_bcp);
				
					
					fclose(fp);
					
					
					//***************************************************************************
					strcpy(f_name,"d:/data/all-");
					strcat(f_name, file_name);
						   
					if((fp = fopen(f_name, "w")) == NULL)
						{
						printf("cannot open file \n");
						exit(1);
						}
					fprintf(fp, "%s\t", f_name);
					fprintf(fp, "fail:\t%d\t", f_bcp);
					fprintf(fp, "succ:\t%d\t", s_bcp);
					fprintf(fp, "fis loss rate:\t%d\t", fis_loss);
					fprintf(fp, "average_hop:\t%f\t", total_average_hop);
					fprintf(fp, "b_average_hop:\t %f\t", b_total_average_hop);
					fprintf(fp, "average delay:\t %f\t", total_average_delay);
					fprintf(fp, "b_average delay:\t%f\t", b_total_average_delay);
					fprintf(fp, "utilization:\t%f\t", utilization);
					fprintf(fp, "loss rate:\t%f\t", loss);
					fprintf(fp, "throughput:\t%f\n", throughput);
					
					for(i=1;i<NODE_NUM;i++)
					{
						for(j=1;j<NODE_NUM;j++)
						{
							if(i != j)
							{
				
								if((fail[i][j] > 0) || (succ[i][j] > 0)) 
									{
									fprintf(fp,"fail[%d][%d] = %d\n", i, j, fail[i][j]);
									fprintf(fp,"succ[%d][%d] = %d\n", i, j, succ[i][j]);
									fprintf(fp,"loss_rate[%d][%d] = %f\n", i,j,loss_rate[i][j]);
									}
							}
						}
					}	
					
					fclose(fp);
					
					}
				
				}


			/** blocking after enter executives of unforced state. **/
			FSM_EXIT (7,Restoration_sink)


			/** state (end) exit executives **/
			FSM_STATE_EXIT_UNFORCED (3, "end", "Restoration_sink () [end exit execs]")
				{
				}


			/** state (end) transition processing **/
			FSM_TRANSIT_MISSING ("end")
				/*---------------------------------------------------------*/



			}


		FSM_EXIT (0,Restoration_sink)
		}
	}

#if defined (__cplusplus)
	extern "C" { 
#endif
	extern VosT_Fun_Status Vos_Catmem_Register (const char * , int , VosT_Void_Null_Proc, VosT_Address *);
	extern VosT_Address Vos_Catmem_Alloc (VosT_Address, size_t);
	extern VosT_Fun_Status Vos_Catmem_Dealloc (VosT_Address);
#if defined (__cplusplus)
	}
#endif


Compcode
Restoration_sink_init (void ** gen_state_pptr)
	{
	int _block_origin = 0;
	static VosT_Address	obtype = OPC_NIL;

	FIN (Restoration_sink_init (gen_state_pptr))

	if (obtype == OPC_NIL)
		{
		/* Initialize memory management */
		if (Vos_Catmem_Register ("proc state vars (Restoration_sink)",
			sizeof (Restoration_sink_state), Vos_Vnop, &obtype) == VOSC_FAILURE)
			{
			FRET (OPC_COMPCODE_FAILURE)
			}
		}

	*gen_state_pptr = Vos_Catmem_Alloc (obtype, 1);
	if (*gen_state_pptr == OPC_NIL)
		{
		FRET (OPC_COMPCODE_FAILURE)
		}
	else
		{
		/* Initialize FSM handling */
		((Restoration_sink_state *)(*gen_state_pptr))->current_block = 0;

		FRET (OPC_COMPCODE_SUCCESS)
		}
	}



void
Restoration_sink_diag (void)
	{
	/* No Diagnostic Block */
	}




void
Restoration_sink_terminate (void)
	{
	int _block_origin = __LINE__;

	FIN (Restoration_sink_terminate (void))

	if (1)
		{
		double 	ete_delay, delay;
		packet* pktr;
		int 	i;
		int		j;
		int 	userid;
		Objid	self_objid;
		Objid	node_objid;
		Objid	subnet_objid;
		int		flag, hop, source_address,route_flag;
		double	average_hop[15][15];
		double	b_average_hop[15][15];
		double	loss;
		int 	fis_loss;
		double	loss_rate[15][15];
		double	total_average_hop, b_total_average_hop;
		double	average_delay[15][15], b_average_delay[15][15];
		double	total_average_delay, b_total_average_delay;
		double	utilization;
		char	file_name[10];
		char	f_name[50];
		int		backup_count;
		FILE 		*fp;
		int		total_gen_bcp, total_all_succ;
		double	throughput;
		int		s_bcp, f_bcp;
		double	start_time;
		
		double	back_average_delay;
		double	back_average_hop;
		double	back_throughput;
		double	back_loss;
		double	back_utilization;
		double	sim_time;

		/* Termination Block */


		BINIT
		

		/* End of Termination Block */

		}
	Vos_Catmem_Dealloc (pr_state_ptr);

	FOUT;
	}


/* Undefine shortcuts to state variables to avoid */
/* syntax error in direct access to fields of */
/* local variable prs_ptr in Restoration_sink_svar function. */
#undef r_count
#undef r_cnt_stathandle
#undef ete_gsh
#undef rev_pk_gen_gsh



void
Restoration_sink_svar (void * gen_ptr, const char * var_name, char ** var_p_ptr)
	{
	Restoration_sink_state		*prs_ptr;

	FIN (Restoration_sink_svar (gen_ptr, var_name, var_p_ptr))

	if (var_name == OPC_NIL)
		{
		*var_p_ptr = (char *)OPC_NIL;
		FOUT;
		}
	prs_ptr = (Restoration_sink_state *)gen_ptr;

	if (strcmp ("r_count" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->r_count);
		FOUT;
		}
	if (strcmp ("r_cnt_stathandle" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->r_cnt_stathandle);
		FOUT;
		}
	if (strcmp ("ete_gsh" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->ete_gsh);
		FOUT;
		}
	if (strcmp ("rev_pk_gen_gsh" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->rev_pk_gen_gsh);
		FOUT;
		}
	*var_p_ptr = (char *)OPC_NIL;

	FOUT;
	}