gpr_route_interface.pr.c

opnet非全连接路由协议

				if (ete_delay<i_Delay_tolerent)
					{
				
				// update the packet received and efficiency statistics
				op_stat_write(stat_packet_received,++packet_received);
				op_stat_write(stat_efficiency,(double)packet_received/(double)packet_transmited);
				sprintf(msg,"rcv %d,tx %d packets,rate is %.2f %%%%,delay %.2f(%.0f~%.0f)",
					packet_received,packet_transmited,
					100*(double)packet_received/(double)packet_transmited,
					ete_delay,create_time,now
					);
				
				
				
					if (op_prg_odb_ltrace_active ("stat") == OPC_TRUE)
						{
				
						printf(msg);
						printf("\n");
							
						}		
				
				
					}
				else
					{
					printf("delay %.1f,limit out:%.1f\n",ete_delay,i_Delay_tolerent);
				//printf("delay %.1f,limit out:%.1f\n",ete_delay,i_Delay_tolerent*f_off_interval);	
					
					
					
					}
				
				// calcul the delay of the packet and update the corresponding statistic
				packet_delay=(op_sim_time()-op_pk_creation_time_get(pk_ptr));
				op_stat_write(stat_ete_delay,packet_delay); 
				
				// calcul the total delay and update the average delay statistic
				total_delay+=packet_delay;
				op_stat_write(stat_average_delay,total_delay/(double)packet_received); 
				
				// update the packet throughput statistic
				op_stat_write(stat_packet_throughput,(double)packet_received/((double)number_of_nodes*op_sim_time()));
				
				// and send the data packet to the sink
				op_pk_send(pk_ptr,TO_SINK_STRM);
				}

				FSM_PROFILE_SECTION_OUT (gpr_route_interface [rx enter execs], state2_enter_exec)

			/** state (rx) exit executives **/
			FSM_STATE_EXIT_FORCED (2, "rx", "gpr_route_interface [rx exit execs]")
				FSM_PROFILE_SECTION_IN (gpr_route_interface [rx exit execs], state2_exit_exec)
				{
				}
				FSM_PROFILE_SECTION_OUT (gpr_route_interface [rx exit execs], state2_exit_exec)


			/** state (rx) transition processing **/
			FSM_TRANSIT_FORCE (1, state1_enter_exec, ;, "default", "", "rx", "idle")
				/*---------------------------------------------------------*/



			/** state (tx) enter executives **/
			FSM_STATE_ENTER_FORCED (3, "tx", state3_enter_exec, "gpr_route_interface [tx enter execs]")
				FSM_PROFILE_SECTION_IN (gpr_route_interface [tx enter execs], state3_enter_exec)
				{
				///////////////////////////////////////////////////////////////
				// TX STATE
				//
				// Processed when a packet to transmit is received from the source 
				///////////////////////////////////////////////////////////////
				
				// extract the packet from the source stream
				pk_ptr=op_pk_get(FROM_SRC_STRM);
				
				// if the node is allowed to transmit new data packets in the network
				if (TRANSMIT)
					{
					
					if (GPR_dest_addr==-1)
						{
					// compute randomly a destination GPR address
					destination_GPR_address=(int)op_dist_outcome(address_dist);
					// check that this destination is not "myself"
					while (destination_GPR_address==my_route_address)
						{
						destination_GPR_address=(int)op_dist_outcome(address_dist);
						}
					
					}
					else
						destination_GPR_address=GPR_dest_addr;
					
					
					// creatre and install an ici to communicate the GPR address of the packet destination to the GPR process model
					iciptr = op_ici_create("GPR_Dest_ICI");
					op_ici_attr_set(iciptr,"GPR_Destination",destination_GPR_address);
					op_ici_install(iciptr);
					// send the packet to the GPR layer
					if (op_prg_odb_ltrace_active ("ztl_debug") == OPC_TRUE)
					{
						printf("A packet to send to %d\n",destination_GPR_address);
					}
					op_pk_send (pk_ptr,TO_ROUTING_LAYER_STRM);
					op_prg_odb_bkpt("ztl_down");
					// and update statistics
					op_stat_write(stat_packet_transmited,++packet_transmited);
					}
				// if the node should not send any new packet
				else
					{
					// the packet is destroyed
					op_pk_destroy(pk_ptr);
					}	
				}

				FSM_PROFILE_SECTION_OUT (gpr_route_interface [tx enter execs], state3_enter_exec)

			/** state (tx) exit executives **/
			FSM_STATE_EXIT_FORCED (3, "tx", "gpr_route_interface [tx exit execs]")
				FSM_PROFILE_SECTION_IN (gpr_route_interface [tx exit execs], state3_exit_exec)
				{
				}
				FSM_PROFILE_SECTION_OUT (gpr_route_interface [tx exit execs], state3_exit_exec)


			/** state (tx) transition processing **/
			FSM_TRANSIT_FORCE (1, state1_enter_exec, ;, "default", "", "tx", "idle")
				/*---------------------------------------------------------*/



			/** state (pre-init) enter executives **/
			FSM_STATE_ENTER_UNFORCED_NOLABEL (4, "pre-init", "gpr_route_interface [pre-init enter execs]")
				FSM_PROFILE_SECTION_IN (gpr_route_interface [pre-init enter execs], state4_enter_exec)
				{
				///////////////////////////////////////////////////////////////
				// GPR INTERFACE PRE-INIT STATE
				//
				// do nothing... just waiting for the gpr model pre-initialisation 
				// completion
				///////////////////////////////////////////////////////////////
				
				// ensure that each node has finised its pre-initialization before going in the init sate
				op_intrpt_schedule_self(op_sim_time(),0);
				}

				FSM_PROFILE_SECTION_OUT (gpr_route_interface [pre-init enter execs], state4_enter_exec)

			/** blocking after enter executives of unforced state. **/
			FSM_EXIT (9,"gpr_route_interface")


			/** state (pre-init) exit executives **/
			FSM_STATE_EXIT_UNFORCED (4, "pre-init", "gpr_route_interface [pre-init exit execs]")
				FSM_PROFILE_SECTION_IN (gpr_route_interface [pre-init exit execs], state4_exit_exec)
				{
				}
				FSM_PROFILE_SECTION_OUT (gpr_route_interface [pre-init exit execs], state4_exit_exec)


			/** state (pre-init) transition processing **/
			FSM_TRANSIT_FORCE (0, state0_enter_exec, ;, "default", "", "pre-init", "init")
				/*---------------------------------------------------------*/



			}


		FSM_EXIT (4,"gpr_route_interface")
		}
	}




void
gpr_route_interface_diag (OP_SIM_CONTEXT_ARG_OPT)
	{
	/* No Diagnostic Block */
	}




void
gpr_route_interface_terminate (OP_SIM_CONTEXT_ARG_OPT)
	{

#if !defined (VOSD_NO_FIN)
	int _op_block_origin = __LINE__;
#endif

	FIN_MT (gpr_route_interface_terminate ())

	Vos_Poolmem_Dealloc_MT (OP_SIM_CONTEXT_THREAD_INDEX_COMMA pr_state_ptr);

	FOUT
	}


/* Undefine shortcuts to state variables to avoid */
/* syntax error in direct access to fields of */
/* local variable prs_ptr in gpr_route_interface_svar function. */
#undef address_dist
#undef my_route_address
#undef my_objid
#undef my_node_objid
#undef my_network_objid
#undef TRANSMIT
#undef GPR_dest_addr
#undef i_Delay_tolerent
#undef f_off_interval

#undef FIN_PREAMBLE_DEC
#undef FIN_PREAMBLE_CODE

#define FIN_PREAMBLE_DEC
#define FIN_PREAMBLE_CODE

VosT_Obtype
gpr_route_interface_init (int * init_block_ptr)
	{

#if !defined (VOSD_NO_FIN)
	int _op_block_origin = 0;
#endif
	VosT_Obtype obtype = OPC_NIL;
	FIN_MT (gpr_route_interface_init (init_block_ptr))

	Vos_Define_Object (&obtype, "proc state vars (gpr_route_interface)",
		sizeof (gpr_route_interface_state), 0, 20);
	*init_block_ptr = 8;

	FRET (obtype)
	}

VosT_Address
gpr_route_interface_alloc (VOS_THREAD_INDEX_ARG_COMMA VosT_Obtype obtype, int init_block)
	{

#if !defined (VOSD_NO_FIN)
	int _op_block_origin = 0;
#endif
	gpr_route_interface_state * ptr;
	FIN_MT (gpr_route_interface_alloc (obtype))

	ptr = (gpr_route_interface_state *)Vos_Alloc_Object_MT (VOS_THREAD_INDEX_COMMA obtype);
	if (ptr != OPC_NIL)
		ptr->_op_current_block = init_block;
	FRET ((VosT_Address)ptr)
	}



void
gpr_route_interface_svar (void * gen_ptr, const char * var_name, void ** var_p_ptr)
	{
	gpr_route_interface_state		*prs_ptr;

	FIN_MT (gpr_route_interface_svar (gen_ptr, var_name, var_p_ptr))

	if (var_name == OPC_NIL)
		{
		*var_p_ptr = (void *)OPC_NIL;
		FOUT
		}
	prs_ptr = (gpr_route_interface_state *)gen_ptr;

	if (strcmp ("address_dist" , var_name) == 0)
		{
		*var_p_ptr = (void *) (&prs_ptr->address_dist);
		FOUT
		}
	if (strcmp ("my_route_address" , var_name) == 0)
		{
		*var_p_ptr = (void *) (&prs_ptr->my_route_address);
		FOUT
		}
	if (strcmp ("my_objid" , var_name) == 0)
		{
		*var_p_ptr = (void *) (&prs_ptr->my_objid);
		FOUT
		}
	if (strcmp ("my_node_objid" , var_name) == 0)
		{
		*var_p_ptr = (void *) (&prs_ptr->my_node_objid);
		FOUT
		}
	if (strcmp ("my_network_objid" , var_name) == 0)
		{
		*var_p_ptr = (void *) (&prs_ptr->my_network_objid);
		FOUT
		}
	if (strcmp ("TRANSMIT" , var_name) == 0)
		{
		*var_p_ptr = (void *) (&prs_ptr->TRANSMIT);
		FOUT
		}
	if (strcmp ("GPR_dest_addr" , var_name) == 0)
		{
		*var_p_ptr = (void *) (&prs_ptr->GPR_dest_addr);
		FOUT
		}
	if (strcmp ("i_Delay_tolerent" , var_name) == 0)
		{
		*var_p_ptr = (void *) (&prs_ptr->i_Delay_tolerent);
		FOUT
		}
	if (strcmp ("f_off_interval" , var_name) == 0)
		{
		*var_p_ptr = (void *) (&prs_ptr->f_off_interval);
		FOUT
		}
	*var_p_ptr = (void *)OPC_NIL;

	FOUT
	}