dr_ack.pr.c

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

			/** state (rcv_ack) transition processing **/
			FSM_INIT_COND (VALID_ACK && Q_NOT_EMPTY)
			FSM_DFLT_COND
			FSM_TEST_LOGIC ("rcv_ack")

			FSM_TRANSIT_SWITCH
				{
				FSM_CASE_TRANSIT (0, 4, state4_enter_exec, ;, "VALID_ACK && Q_NOT_EMPTY", "", "rcv_ack", "send")
				FSM_CASE_TRANSIT (1, 1, state1_enter_exec, ;, "default", "", "rcv_ack", "wait")
				}
				/*---------------------------------------------------------*/



			/** state (send) enter executives **/
			FSM_STATE_ENTER_FORCED (4, state4_enter_exec, "send", "dr_ack () [send enter execs]")
				{
				/* obtain a packet at the head of the buffer */
				pkptr = op_subq_pk_remove (0, OPC_QPOS_HEAD);
				queue_size--;
				
				/* get the sequence number of this packet */
				op_pk_nfd_get (pkptr, "sequence number", &sequence_number_wait);
				
				/* get the packet's destination address */
				op_pk_nfd_get (pkptr, "destination address", &destination_address);
				
				/* if debug switch is on */
				if (debug_sw) 
					{
					printf ("node = %d, send out pk for %d, seq num = %d\n", node_address, destination_address,
						sequence_number_wait);
				    }
				
				/* send out the packet to the SAR */
				op_pk_send (pkptr, RTE_OUT_STRM);
				
				
				}


			/** state (send) exit executives **/
			FSM_STATE_EXIT_FORCED (4, "send", "dr_ack () [send exit execs]")
				{
				}


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



			/** state (pk type) enter executives **/
			FSM_STATE_ENTER_FORCED (5, state5_enter_exec, "pk type", "dr_ack () [pk type enter execs]")
				{
				/* obtain the packet from the lower layer */
				pkptr = op_pk_get (RTE_IN_STRM);
				
				/* get the packet format */
				op_pk_format (pkptr, pk_format);
				
				 
				}


			/** state (pk type) exit executives **/
			FSM_STATE_EXIT_FORCED (5, "pk type", "dr_ack () [pk type exit execs]")
				{
				}


			/** state (pk type) transition processing **/
			FSM_INIT_COND (ACK_ARRIVAL)
			FSM_TEST_COND (PK_ARRIVAL)
			FSM_TEST_LOGIC ("pk type")

			FSM_TRANSIT_SWITCH
				{
				FSM_CASE_TRANSIT (0, 3, state3_enter_exec, ;, "ACK_ARRIVAL", "", "pk type", "rcv_ack")
				FSM_CASE_TRANSIT (1, 6, state6_enter_exec, ;, "PK_ARRIVAL", "", "pk type", "rcv_pk")
				}
				/*---------------------------------------------------------*/



			/** state (rcv_pk) enter executives **/
			FSM_STATE_ENTER_FORCED (6, state6_enter_exec, "rcv_pk", "dr_ack () [rcv_pk enter execs]")
				{
				/* determine the source of the packet and the sequence number */
				op_pk_nfd_get (pkptr, "source address", &source_address);
				op_pk_nfd_get (pkptr, "sequence number", &sequence_number_rcv);
				
				/* if ack is required, generate an ack and send it to rte */
				if (ack != FALSE) 
					{ 
				
					/* create an ack packet */
					ack_pkptr = op_pk_create_fmt ("dr_ack");
					op_pk_total_size_set (ack_pkptr, ACK_PK_SIZE); 
				
					/* set the source, destination and ack sequence number for this ack */
					op25_pk_nfd_set (ack_pkptr, "source address", node_address);
					op25_pk_nfd_set (ack_pkptr, "destination address", source_address);
					op25_pk_nfd_set (ack_pkptr, "sequence number ack", sequence_number_rcv);
				
					/* send out the ack packet */	 
					op_pk_send (ack_pkptr, RTE_OUT_STRM);
				    }
				
				/* if not duplicated, send out the received packet to higher layer */
				if (pk_rcvd[source_address] < sequence_number_rcv) 
					{
				
					/* if debug switch is on */
					if (debug_sw)
						{	
						printf ("\tnode = %d, rcv pk from %d, seq num = %d\n", node_address, source_address, sequence_number_rcv);
						}
				
					/* update the sequence number received for the specific souce node */
					pk_rcvd[source_address] = sequence_number_rcv;
					op_pk_send (pkptr, APP_OUT_STRM);
				    }
				else
					{
				
					/* a duplicated packet has been received */
				
					/* if debug switch is on */
					if (debug_sw)
						{
						printf ("\t*****node = %d, rcv pk from %d, seq num = %d\n", node_address, source_address, sequence_number_rcv);
					    }
					/* increment the the number of duplicated packets received */
					dup_pk++;
				
					/* write a new data point for the duplicated packets */
					op_stat_write (dup_pk_gsh, dup_pk);
				
					/* destroy the duplicated packet */
					op_pk_destroy (pkptr);
					}
				}


			/** state (rcv_pk) exit executives **/
			FSM_STATE_EXIT_FORCED (6, "rcv_pk", "dr_ack () [rcv_pk exit execs]")
				{
				}


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



			/** state (end) enter executives **/
			FSM_STATE_ENTER_UNFORCED (7, state7_enter_exec, "end", "dr_ack () [end enter execs]")
				{
				/* only one node needs to write out the output scalar */
				if (!ack_reentry)
					{
					op_stat_scalar_write ("APP_PK_GENERATED (pks)", (double) num_pk_gen);
				    ack_reentry = 1;
					}
				}


			/** blocking after enter executives of unforced state. **/
			FSM_EXIT (15,dr_ack)


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


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



			}


		FSM_EXIT (0,dr_ack)
		}
	}

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

	FIN (dr_ack_init (gen_state_pptr))

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

		FRET (OPC_COMPCODE_SUCCESS)
		}
	}



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




void
dr_ack_terminate (void)
	{
	int _block_origin = __LINE__;

	FIN (dr_ack_terminate (void))

	if (1)
		{
		Packet*		pkptr;
		Packet*		ack_pkptr;
		Objid		my_id;
		Objid		dest_node_objid;
		char		pk_format[120];
		int			sequence_number_ack;
		int			sequence_number_rcv;
		int			source_address;
		int			destination_address;
		int			i;
		Boolean		valid_ack;

		/* 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 dr_ack_svar function. */
#undef sequence_number_wait
#undef sequence_number_current
#undef node_address
#undef nodes_total
#undef queue_size
#undef ack
#undef dest_method
#undef pk_rcvd
#undef destination_scheme
#undef address_dist
#undef sar_mod_objid
#undef node_id
#undef num_pk_gen_gsh
#undef dup_pk_gsh



void
dr_ack_svar (void * gen_ptr, const char * var_name, char ** var_p_ptr)
	{
	dr_ack_state		*prs_ptr;

	FIN (dr_ack_svar (gen_ptr, var_name, var_p_ptr))

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

	if (strcmp ("sequence_number_wait" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->sequence_number_wait);
		FOUT;
		}
	if (strcmp ("sequence_number_current" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->sequence_number_current);
		FOUT;
		}
	if (strcmp ("node_address" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->node_address);
		FOUT;
		}
	if (strcmp ("nodes_total" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->nodes_total);
		FOUT;
		}
	if (strcmp ("queue_size" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->queue_size);
		FOUT;
		}
	if (strcmp ("ack" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->ack);
		FOUT;
		}
	if (strcmp ("dest_method" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->dest_method);
		FOUT;
		}
	if (strcmp ("pk_rcvd" , var_name) == 0)
		{
		*var_p_ptr = (char *) (prs_ptr->pk_rcvd);
		FOUT;
		}
	if (strcmp ("destination_scheme" , var_name) == 0)
		{
		*var_p_ptr = (char *) (prs_ptr->destination_scheme);
		FOUT;
		}
	if (strcmp ("address_dist" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->address_dist);
		FOUT;
		}
	if (strcmp ("sar_mod_objid" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->sar_mod_objid);
		FOUT;
		}
	if (strcmp ("node_id" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->node_id);
		FOUT;
		}
	if (strcmp ("num_pk_gen_gsh" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->num_pk_gen_gsh);
		FOUT;
		}
	if (strcmp ("dup_pk_gsh" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->dup_pk_gsh);
		FOUT;
		}
	*var_p_ptr = (char *)OPC_NIL;

	FOUT;
	}