blocking_estimate.pr.c

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

											//getchar();
											
											convert_wave_save = wave_convert;
											break;
											}
										}
									
									 if(CONVERT_FAIL == 1)
										{
										break;
										}   
									 }
								 											
								else
									{
									//SPECIAL_RECE = 1;
									CONVERT_FAIL = 1;
									convert_wave_save = wave_convert;
									
									//printf("list[wave_convert:%d]===== 0--->insert directly!\n",wave_convert);
									//break;
									
									}
								}
							}
						
						
						if(CONVERT_FAIL == 0)
							{
							
							ordinary_lost++;
							
							op_pk_destroy(pkptr);
							
							//printf("ENDING FAIL-->wavelength convertor on all wavelengths failed!!!\n");
							//getchar();
							}
						}
					}
					
					//printf("\nOriginal wave_id:%d, convert wave_save:%d\n", wave_id, convert_wave_save);
					//getchar();
					
					if((wave_id != 4)&&((CONVERT_FLAG == 0)||((CONVERT_FLAG == 1)&&(CONVERT_FAIL == 1))))
						{
						
						/*if(CONVERT_FLAG == 0)
							{
							
							printf("As current wavelength is avaible, just send it\n");
							getchar();
							}
						
						if(CONVERT_FLAG == 1)
							{
							printf("As current wavelength is not avaible, wave_convertor succeed\n");
							getchar();
							}*/
						
						
						ordinary_send++;
						
						op_prg_list_insert(CIT[convert_wave_save],burst_into_table, OPC_LISTPOS_TAIL);
						op_prg_list_sort(CIT[convert_wave_save], compare);
						
						op_pk_send(pkptr,1);
						
						list[convert_wave_save] = op_prg_list_size(CIT[convert_wave_save]);
						
						if(list[convert_wave_save] !=0)
							{
										
							for(i=0; i<list[convert_wave_save]; i++)
								{
								
								debug_check_table = op_prg_list_access(CIT[convert_wave_save],i);
								
								debug_in = debug_check_table->Tsend;
								debug_out = debug_check_table->Tdepart;
									
								//printf("ENDING SUCCEED-->CIT[convert_wave_save:%d]:%d\n",convert_wave_save, list[convert_wave_save]);
								//printf("Debug_in: %e, Debug_out: %e\n", debug_in, debug_out);
								//getchar();
								//printf("Burst_send--->cur_wave:%d\n",convert_wave_save);
								//getchar();
								}
							}
						}
				
						
				
				/******************** If failed, do statistic for the special bursts ***********************/
							
				if(wave_id == 4)
					{
					//printf("START-->current_in: %e, current_out:%e\n", cur_in, cur_out);
					//printf("If wave_id =============================== 4!!!!\n");
					//getchar();
					
					for(wave_insert = 0; wave_insert < 4; wave_insert++)
						{
						
						list[wave_insert] = op_prg_list_size(CIT[wave_insert]);
						//printf("current_wave: %d, # of bursts on it: %d\n", wave_insert, list[wave_insert]);
						//getchar();
						
						if(list[wave_insert] !=0)
							{
							
							for(i=0; i < list[wave_insert]; i++)
								{
								
								wave_insert_table = op_prg_list_access(CIT[wave_insert],i);
								insert_in = wave_insert_table->Tsend;
								insert_out = wave_insert_table->Tdepart;
								
								if((cur_in>=insert_in)&&(cur_in<insert_out))
									{
									//printf("Wave_insert: %d\n", wave_insert);
									//printf("insert_in: %e, insert_out: %e\n", insert_in, insert_out);
									break;
									}
									
						/************ If reservation on one wavelength succeeds, send burst on it ************/
								else
									{
									//printf("insert_in: %e, insert_out: %e\n", insert_in, insert_out);
									SPECIAL_RECE = 1;
									break;
									}
								}
						
							if(SPECIAL_RECE == 1)
								{
								break;
								}
							}
						
						else
							{
							SPECIAL_RECE = 1;
							break;
							}
						}
					
					
					if(SPECIAL_RECE == 1)
						{
						
						op_prg_list_insert(CIT[wave_insert],burst_into_table, OPC_LISTPOS_TAIL);
						op_prg_list_sort(CIT[wave_insert], compare);
						
						op_pk_send_delayed(pkptr,1, offset_time);
						//printf("ENDING SUCCEED on wave: %d\n", wave_insert);
						//getchar();
						
						special_send++;
						}
					
					else
						{
						special_lost++;
				
						//printf("ENDINIG FAILED on wave\n");
						//getchar();
						op_pk_destroy(pkptr);
						}
					}
					
				//printf("Blocking_estinmate-->BLOCKING_CALCULATE---->End!\n");
				//getchar();
				}


			/** state (blocking_calculate) exit executives **/
			FSM_STATE_EXIT_FORCED (2, "blocking_calculate", "blocking_estimate () [blocking_calculate exit execs]")
				{
				}


			/** state (blocking_calculate) transition processing **/
			FSM_TRANSIT_FORCE (1, state1_enter_exec, ;, "default", "", "blocking_calculate", "wait")
				/*---------------------------------------------------------*/



			/** state (END) enter executives **/
			FSM_STATE_ENTER_UNFORCED (3, state3_enter_exec, "END", "blocking_estimate () [END enter execs]")
				{
				
				op_ima_obj_attr_get(self_objid, "filename", &filename);
				
				//strcpy(temp_file_name,"D:/result analysis/offered-0.1/");
				strcpy(temp_file_name,"D:/result analysis/offset is equal/");
				
				strcpy(temp_file_name,"D:/result analysis/one generator/");
				
				
				//strcpy(temp_file_name,"D:/result analysis/offset-1 but diff-uniform/");
				
				strcat(temp_file_name,filename);
				strcat(temp_file_name,".txt");
					
				in = fopen(temp_file_name, "w");
				
				fprintf(in, "\tSpecial_come: %d\n", special_rece);
				fprintf(in, "\tSpecial_send: %d\n", special_send);
				fprintf(in, "\tSpecial_lost: %d\n", special_lost);
				
				fprintf(in, "\tordinary_come: %d\n", ordinary_rece);
				fprintf(in, "\tordinary_send: %d\n", ordinary_send);
				fprintf(in, "\tordinaryl_lost: %d\n", ordinary_lost);
				
				
				
				//fprintf(in, "\nordinaryl_total_size: %e\n", ordinary__total_size);
				
				fclose(in);
					
				//printf("\nBlocking_estinmate-->END_SIM---->Check!\n");
				//getchar();
				}


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


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


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



			}


		FSM_EXIT (0,blocking_estimate)
		}
	}

#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
blocking_estimate_init (void ** gen_state_pptr)
	{
	int _block_origin = 0;
	static VosT_Address	obtype = OPC_NIL;

	FIN (blocking_estimate_init (gen_state_pptr))

	if (obtype == OPC_NIL)
		{
		/* Initialize memory management */
		if (Vos_Catmem_Register ("proc state vars (blocking_estimate)",
			sizeof (blocking_estimate_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 */
		((blocking_estimate_state *)(*gen_state_pptr))->current_block = 0;

		FRET (OPC_COMPCODE_SUCCESS)
		}
	}



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




void
blocking_estimate_terminate (void)
	{
	int _block_origin = __LINE__;

	FIN (blocking_estimate_terminate (void))

	if (1)
		{
		//int           strm_type;
		int           offset_type;
		//int           wave_id;
		int           list[5];
		
		int           i;
		int           wave_update;
		int           wave_convert;
		int           wave_insert;
		int           debug_list;
		
		double        arrive_time;
		double        depart_time;
		double        check_in;
		double        check_out;
		
		double        convert_in;
		double        convert_out;
		
		double        insert_in;
		double        insert_out;
		
		double        debug_in;
		double        debug_out;
		
		double        cur_in;
		double        cur_out;
		
		double        rest_offset;
		
		double        cur_send;
		double        cur_depart;
		
		double        burst_size;
		
		burst_pass*   burst_into_table;
		burst_pass*   burst_check_table;
		burst_pass*   list_update;
		burst_pass*   wave_convert_table;
		burst_pass*   wave_insert_table;
		burst_pass*   debug_check_table;
		
		char          temp_file_name[50];

		/* No 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 blocking_estimate_svar function. */
#undef self_objid
#undef node_objid
#undef denominator
#undef numerator
#undef pkptr
#undef offset_time
#undef PK_SEND_FLAG
#undef userid
#undef strm_num
#undef strm_type
#undef CONVERT_FLAG
#undef convert_wave_save
#undef wave_id
#undef CONVERT_FAIL
#undef SPECIAL_RECE
#undef burst_length



void
blocking_estimate_svar (void * gen_ptr, const char * var_name, char ** var_p_ptr)
	{
	blocking_estimate_state		*prs_ptr;

	FIN (blocking_estimate_svar (gen_ptr, var_name, var_p_ptr))

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

	if (strcmp ("self_objid" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->self_objid);
		FOUT;
		}
	if (strcmp ("node_objid" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->node_objid);
		FOUT;
		}
	if (strcmp ("denominator" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->denominator);
		FOUT;
		}
	if (strcmp ("numerator" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->numerator);
		FOUT;
		}
	if (strcmp ("pkptr" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->pkptr);
		FOUT;
		}
	if (strcmp ("offset_time" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->offset_time);
		FOUT;
		}
	if (strcmp ("PK_SEND_FLAG" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->PK_SEND_FLAG);
		FOUT;
		}
	if (strcmp ("userid" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->userid);
		FOUT;
		}
	if (strcmp ("strm_num" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->strm_num);
		FOUT;
		}
	if (strcmp ("strm_type" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->strm_type);
		FOUT;
		}
	if (strcmp ("CONVERT_FLAG" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->CONVERT_FLAG);
		FOUT;
		}
	if (strcmp ("convert_wave_save" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->convert_wave_save);
		FOUT;
		}
	if (strcmp ("wave_id" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->wave_id);
		FOUT;
		}
	if (strcmp ("CONVERT_FAIL" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->CONVERT_FAIL);
		FOUT;
		}
	if (strcmp ("SPECIAL_RECE" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->SPECIAL_RECE);
		FOUT;
		}
	if (strcmp ("burst_length" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->burst_length);
		FOUT;
		}
	*var_p_ptr = (char *)OPC_NIL;

	FOUT;
	}