Lab 3: Performance Analysis of ALOHA

Transcription

1 Lab 3: Performance Analysis of ALOHA ALOHA is one of the basic random access methods in mobile data networks. It is based on mobile terminals sending their packets without any coordination between them. The main advantage of using ALOHA access method is its simplicity and the ease of applicability. No synchronization between mobile transmitters is required. The terminals basically transmit their packets as soon as they receive them from higher layers and if there is a collision at the receiver side, they basically retransmit the packet. The collision is detected at the receiver side by a simple error detection code. The disadvantage of the ALOHA is its low throughput under heavy load conditions. (i.e. the number of collisions are going to increase as the number of users increase.) In this third OPNET lab, we are going to simulate ALOHA random access protocol and answer the following simple questions about ALOHA based random access methods. 1) What is the behavior of ALOHA throughout as the load of the network increases? 2) What is the maximum achievable network throughput by using ALOHA? 3) Do the simulation results verify analytical results? (Show that the maximum throughout values match) 4) How one can improve the throughout performance of ALOHA? 5) What type of relation would be observed between network load and throughput if there is one and only one user transmitting? Overview In this lab, the complete simulation model of ALOHA protocol is explained and simulated step-bystep. All the simulation components that are going to be used in ALOHA model is designed from scratch in order to understand the capabilities and the structure of OPNET. Such a detailed analysis is not going to be performed and built in functions and modules are going to be used in the following lab. The main task of this lab is to design a model that includes a multi-tap bus link, where multiple stations (i.e. transmitters) utilizing ALOHA random access protocol share a common channel. ALOHA Simulation Hierarchy in OPNET In order to implement ALOHA method, we must have multiple transmitters, a multi-tap bus line and a single receiver in the network configuration. We will use node model to build each transmitter and receiver structure. And we know from Lab 2, OPNET Tutorial, that we will need to use the process model in order to define the behavior of the each node in the node model. (e.g. Transmitter should retransmit the packet in case of collision.) The generic OPNET hierarchy and the corresponding names that we will assign on each model is illustrated in the figure below. When working with new files, you can use your student number in order to differentiate the files you are working from already built-in ones. A possible file name and an example illustration for the corresponding model is shown in the figure. The network model consists of two node models (one for transmitter and one for receiver node) and each node model is made up of process models, which define the behavior of each node. Step-bystep design and construction of each model is illustrated. The main purpose of this lab is to illustrate the interactions between different OPNET hierarchy. (i.e. How process models are assigned to node models or how do two different node models communicate with each other?) CEG4190 Lab 3 page 1 of 11

2 Illustration 1: ALOHA simulation components and simulation overview Step by step building of the network structure is as follows: Create a transmitter process model and specify the characteristic of transmitter node Create a node for transmitter in node model Create a receiver process model and specify the characteristic of receiver node Create a node for receiver in node model Create a bus link model for shared environment Create a network model by using the created transmitter and receiver nodes Choose the simulation parameters to observe and vary Analyze the performance of the system CEG4190 Lab 3 page 2 of 11

3 The network model, node model and the process model that we are going to built for ALOHA random access method is illustrated in the figure below. It shows the network that consist of 20 transmitters sharing the same bus link and sending packets to a single receiver. The node models and process models of each receiver and transmitter are illustrated. Before starting the network design, lets look at the each node and process model individually. Illustration 2: ALOHA network-node-process model illustration The transmitter node basically generates packets, process them (i.e. counts the number of packets it generates for network load calculation) and sends them on the bus. This can be modeled in the node model by using a simple source, a processor and a bus transmitter nodes. Data source and bustransmitter nodes are built-in nodes in the node model. We only need to create processor node that relays the packets to bus-transmitter when activated and counts the number of packets sent. The receiver node basically monitors the collisions on the bus. Therefore it is consist of a bus receiver and a processor module. The receiver process model specifies the behavior of the custom processor module. It is responsible for handling received packets for statistical collection. It manages this statistics by creating and modifying global variables. Basically it counts the number of the successfully received packets (network throughput) and destroys the received packets (i.e. We are only concerned about the number of the packets that are received correctly, the contents of packets are not important). After creating the relevant process and node models for receiver and transmitters, we will connect those models with a multi-tab bus on the network model. We will be investigating the throughput performance of ALOHA random access protocol. Using a built-in simulation sequence editor we will simulate the same network in different loading conditions. That is to say, the already prepared simulation sequence editor will assign different packet inter-arrival times to transmitters in each simulation. In total, 12 simulations are going to be performed. Simulation results will be written on a scalar file and simulation analysis editor will be used to observe simulation results. Let's start building our model with transmitter (Tx) process model. CEG4190 Lab 3 page 3 of 11

4 Designing ALOHA Tx Process Model 1) Start modeler. 2) From the menu choose: File > New > Process Model. And click Ok. 3) We are going to create two states for transmitter by create state button. Name them Idle state (transmitter waiting for an transmit interrupt) and Transmit state (Transmitter is actively involved in transmission.). You can turn off the state creation by right clicking on the process model window. 4) A transmitter is supposed to transmit when a new packet arrived and go back to listen ( Idle ) state. Therefore, we should change the status of the Transmit state to forced by right clicking on it and choosing Make State Forced option from the pop-up menu. 5) Draw the transitions between states by. Remember that the transition from Idle to Transmit occurs if a new packet arrives. Therefore it is a conditional transition. To implement this condition on the transition, right click on the transition line and type PKT_ARVL to condition attribute. Draw another transition from Transmit to idle state with no condition. 6) Header block of the process model is used for defining the conditions in the transitions, declaring global variables and indicating the streaming of the process node (The connectivity of the node. e.g. input stream from data generator and output stream to bus transmitter). Open the header block and enter the code shown. /* Input stream from generator module */ #define IN_STRM 0 /* Output stream to bus transmitter module */ #define OUT_STRM 0 /* Conditional macros */ #define PKT_ARVL (op_intrpt_type() == OPC_INTRPT_STRM) /* Global Variable */ extern int subm_pkts; 7) Temporary variables are the ones that change on every call of the process model. The only parameter that changes on each call of the processor is the incoming packet. Therefore define a packet pointer in the temporary variable block. /* Outgoing packet */ Packet *out_pkt; When we start the simulation, we don t want it to continue forever. Therefore we create an integer variable max_packet_count on state variable tab of process model. State variables keep their value throughout the simulation. We will assign its value while specifying simulation parameters. 8) After defining the parameters, we will set the enter and exit executives of the Idle and Transmit states. The Idle state only retrieves the maximum packet number value. The Transmit state acquire the packet from the input stream, send the packet, updates the global submitted packet counter and ends the simulation if the packet counter value reaches to max_packet_count. Therefore enter the following code for enter executive block of the Idle state /* Get the maximum packet count, */ /* set at simulation run-time */ CEG4190 Lab 3 page 4 of 11

5 op_ima_sim_attr_get (OPC_IMA_INTEGER, "max packet count", &max_packet_count); and the following code to enter executive block of Transmit state: /* A packet has arrived for transmission. Acquire */ /* the packet from the input stream, send the packet */ /* and update the global submitted packet counter. */ out_pkt = op_pk_get (IN_STRM); op_pk_send (out_pkt, OUT_STRM); ++subm_pkts; /* Compare the total number of packets submitted with */ /* the maximum set for this simulation run. If equal */ /* end the simulation run. */ if (subm_pkts == max_packet_count) { op_sim_end ("max packet count reached.", "", "", ""); } The variable subm_pkts is a global variable that will be declared later by the receiver. 9) When we want to run a simulation, we will need to assign the max_packet_count value to simulation editor in order to let him know when to end the simulation. Therefore, we need to define a global attribute that could be set at simulation run time and loaded into the state variable max_packet_count. From process model menu, go to : Interfaces > Global Attributes and enter max packet count as a type integer. 10) Finally you should edit process interfaces. From the menu go to : Interfaces > Process Interfaces and change the initial value of the begsim_intrpt attribute to enabled and change the status of all the attributes to hidden. This would enable the first interrupt event when the simulation begins. 11) After writing the source code and doing all the modification we should compile the code by clicking on the orange compile process model button and save the process model as pm_<student_number>_tx e.g. pm_ _tx. After all the steps, your process model should look like: CEG4190 Lab 3 page 5 of 11

6 Illustration 3: Transmitter process model Designing ALOHA Tx Node Model 1) From the menu of Process Model choose: File > New >Node Model. And click Ok. 2) Create two processor modules and one bus transmitter. Name the two processor modules as gen and tx_proc and name bus transmitter as bus_tx. 3) Connect the gen to tx_proc and tx_proc to bus transmitter by packet streams. 4) Set the process model attribute of the gen to simple_source and the same attribute of tx_proc to the created process model pm_ _tx. 5) In the transmitter node model, we are interested in assigning different values to the generators inter arrival time attribute of the gen. Therefore we had better promote this attribute to a higher layer (network layer) so we could more easily change the value and observe the changes. We can do that change by right clicking on the Packet Interarrival Time attribute of gen and choosing Promote to higher layer option. 6) Finally save the node model as nm_ _tx. Your node model should look like: CEG4190 Lab 3 page 6 of 11

7 Illustration 4: Transmitter node model Designing ALOHA Rx Process Model Illustration 5: Receiver process model 1) From the menu of Process Model choose: File > New >Process Model. And click Ok. 2) Create two states and name them as init and idle. Change the status of the init state to forced by right clicking on the state and choosing make state forced option. 3) Draw the state transitions as shown below. We should understand the functionality of each state and each transition of the process model. The basic functionality of the receiver is to wait for the packet to arrive and upon arrival, to update the relevant statistics of the network. This behavior can be clearly seen from the process model illustrated below. When simulation starts receiver goes into init state, where it assigns an initial value to all the simulation parameters (e.g. max_packet_count = 0). Upon arrival of a packet (PKT_RCVD condition) it executes proc_pkt() function and changes state to idle. proc_pkt() function basically receives packet, increases the packet count and deletes the packet. The transition between init and idle state can occur if simulation terminated (END_SIM condition). At the end of the simulation all the statistics should be collected by record_stats() function. After passing to idle state, receiver CEG4190 Lab 3 page 7 of 11

8 basically waits for either packet to arrive or simulation end command. default condition is required in case of any other interrupt affecting the receiver. 4) Assign the conditions of transitions by modifying condition attribute of the transitions and functions to be executed by modifying executive attribute of the transitions in the process model as illustrated in the figure. 5) Using the header block of process model, define conditional macros, global variables and input streams by typing: /* Input stream from bus receiver */ #define IN_STRM 0 /*conditional macros */ #define PKT_RCVD (op_intrpt_type () == OPC_INTRPT_STRM) #define END_SIM (op_intrpt_type () == OPC_INTRPT_ENDSIM) /* Global variable */ int subm_pkts = 0; 6) The receiver process model uses rcvd_pkts state variable to keep track of the number of valid received packets. (Notice that it is a state variable which keeps its value between process model executions.) Open the state variables block and define rcvd_pkts variable as an integer 7) In the receiver process model, we utilize two different functions: proc_pkt() and record_stats() for packet receiving and statistic writing. We should define those functions in the function block of the process model. Open the function block of the process model and enter the following code: /* This function gets the received packet, destroys */ /* it, and logs the incremented received packet total*/ void proc_pkt () { Packet* in_pkt; /* Get packet from bus receiver input stream */ in_pkt = op_pk_get (IN_STRM); /*Destroy the received packet */ op_pk_destroy (in_pkt); /* Increment the count of received packet */ ++rcvd_pkts; } /* This function writes the end-of-simulation channel */ /* traffic and channel throughput statistics to a */ /* scalar file */ void record_stats () { /* Record final statistics */ op_stat_scalar_write("channel Traffic G",(double) subm_pkts / op_sim_time ()); op_stat_scalar_write("channel Throughput S",(double) rcvd_pkts / op_sim_time ()); } CEG4190 Lab 3 page 8 of 11

9 As seen from the code the channel load (G) is defined as the number of packets sent during the simulation interval and the channel throughput (S) is defined as the number or successfully received packets during the simulation interval. 8) After defining the variables and functions of the process model, we only need to define the enter executive of the init state. Double click on the top half of the init state and enter the following code: /* Initialize accumulator */ rcvd_pkts = 0; 9) Like we have done for the transmitter process model, we need to modify the process interfaces of receiver model too. Namely, Choose Interfaces > Process Interfaces. Change the initial value of the endsim intrpt attribute to enabled and change the status of all the attributes to hidden 10) Finally, compile the process model by clicking orange compile process model button on the process model window and save the process model as pm_ _rx. Designing ALOHA Rx Node Model 1) From the menu of Process Model choose: File > New >Node Model. And click Ok. 2) Create one process module and one bus receiver module. Name process module as rx_proc and bus receiver module as bus_rx. 3) Connect bus_rx with packet stream to rx_proc. 4) Open rx_proc s attribute dialog box by right clicking and assign its process model to pm_ _tx process model that we have created in the previous section. 5) Change the node interfaces. Choose Interfaces > Node Interfaces. In the Node Types table, change the Supported value to no for the mobile and satellite types. In the Attributes table, change the Status of all the attributes to hidden. 6) Save the Node Model as nm_ _rx. Designing ALOHA Link Model 1) From the menu of Process Model choose: File > New >Link Model. And click Ok. 2) In the Supported Link Types table, change the supported value to no for the ptsimp and ptdup types. Which means this link supports only the bus and bus tap types. 3) Save the Link Model as lm_ Designing ALOHA Network Model 1) From the menu of Process Model choose: File > New >Project. And click Ok. 2) Name the project as: proj_ and the scenario as Aloha. Click Ok. Follow the widzard as: Create Empty Scenario > Office > 700 m x 700 m > None of the technologies and Ok. 3) On the object palette: Configure Palette > Clear. Add lm_ link model and nm_ _tx, nm_ _rx node models to the palette 4) From the Project window menu: Topology > Rapid configuration > Bus. Enter the values as given below: 5) With that topology we created 20 transmitters. But we need to add drag and drop the receiver node model and connect bus to receiver with the tap link. Be aware that connecting the receiver to bus would result in different results. To be on the safe side connect bus to the receiver. CEG4190 Lab 3 page 9 of 11

10 Illustration 6: Rapid configuration example 6) After completing all the steps and naming the receiver node model as RX, your project editor should look like the figure below: Illustration 7: Project model Executing the ALOHA Simulation In this section we will analyze the throughput performance of ALOHA random access protocol under different load conditions. 12 different simulation are done simultaneously with simulation editor. The network loading is going to be changed by editing data inter-arrival time of transmitters. We will CEG4190 Lab 3 page 10 of 11

11 analyze the simulations and compare with the theoretical results. Simulation sequence is already prepared for you, so you need to import and configure the Simulation sequence. 1) Choose Scenarios > Scenario Components > Import 2) Select Simulation Sequence from the menu and select cct_network-csma 3) Choose Simulation > Configure Discrete Event Simulation (Advanced) 4) Right click on the simulation sequence icon and select Edit Attributes 5) Click on Advanced tab. Verify that Network is set to Proj_ Aloha. 6) Set Probe file to NONE 7) Set Scalar file to lab2_cct_a. 8) Click on Global Attributes tab and verify that max packet count is ) Click on the Object Attributes tab to see 12 values that have been set for transmitter inter arrival times. 10) Save the file. 11) Click on the Execute Simulation Sequence action button and confirm the execution. Analyzing the Aloha Results Aloha random access performance can be measured by comparing the number of successfully received packets to the number of transmitted packets. Because of the collision on the bus link, some of the packets will be lost. And as the loading increases, the number of collisions would increase which would cause the number of successfully received packets decrease. In network communication terminology, throughput term is used to represent the number of successfully received packets. The result of the simulations are stored in a scalar file. In the simulation editor, 12 different inter-arrival times for the transmitters are assigned and the network throughput is calculated for each simulation. The network performance can be observed by plotting the network throughput with the network loading. To open the scalar output file: 1) In the Project Editor, choose File > New then select Analysis Configuration. Click Ok. 2) Choose File > Load Output Scalar File 3) Select lab2_cct_a from the list of available files. 4) Click on the Create a graph of two scalars action button. 5) Select the horizontal variable Channel Traffic G first, then select the vertical variable Channel Throughput S from the menu of available scalars that appears. 6) Observe the graph and comment on the following questions. Questions 1) Explain the increase the channel throughput until the loading of 0.5 G and the reason behind the decrease of the throughput. 2) What is the value of the maximum throughput and prove the obtained value by working on the theoretical network throughput formula of ALOHA random access model: S = Ge -2G 3) In the network set up we had 20 transmitters. Would we have the same network throughput graph by increasing the number of transmitters to 40 and decrease the inter-arrival time of each transmitter by half? Why or why not? 4) On the project editor, keep only one transmitter and erase the rest 19 transmitters. Plot the throughput and load curve and comment on the obtained curve. 5) We know that slotted ALOHA has a better throughput performance than ALOHA protocol. If we want to implement slotted ALOHA, what type of changes and where (i.e. transmitter module, receiver module) should we make the changes on the network simulation set up? CEG4190 Lab 3 page 11 of 11