MCSL 223 Solved Guess Paper 2026 | Computer Networks and Data Mining Lab | IGNOU MCA_NEW and MCAOL

Sample 1 (Section A): Point-to-Point Topology and Throughput While Varying Latency

Create a simple point to point network topology using two nodes. Also, measure the throughput (end to end) while varying latency in the network. Make necessary assumptions.

Assumptions: two nodes n0 and n1 on one 5 Mbps point-to-point link; n0 sends TCP data using an OnOff application and n1 receives it with a PacketSink; link delay is passed on the command line with a 2 ms default; the sender is on from 1 s to 10 s, giving 9 seconds of sending time.

/* Program: Point-to-point network with two nodes.
   Purpose: send TCP traffic from n0 to n1 and measure end-to-end throughput. */
#include "ns3/core-module.h"
#include "ns3/network-module.h"
#include "ns3/internet-module.h"
#include "ns3/point-to-point-module.h"
#include "ns3/applications-module.h"
using namespace ns3;

int main (int argc, char *argv[])
{
  std::string delay = "2ms";
  CommandLine cmd (__FILE__);
  cmd.AddValue ("delay", "Delay of the point-to-point link", delay);
  cmd.Parse (argc, argv);

  NodeContainer nodes;  nodes.Create (2);

  PointToPointHelper pointToPoint;
  pointToPoint.SetDeviceAttribute ("DataRate", StringValue ("5Mbps"));
  pointToPoint.SetChannelAttribute ("Delay", StringValue (delay));
  NetDeviceContainer devices = pointToPoint.Install (nodes);

  InternetStackHelper stack;  stack.Install (nodes);
  Ipv4AddressHelper address;
  address.SetBase ("10.1.1.0", "255.255.255.0");
  Ipv4InterfaceContainer interfaces = address.Assign (devices);

  uint16_t port = 9;
  OnOffHelper onoff ("ns3::TcpSocketFactory",
      Address (InetSocketAddress (interfaces.GetAddress (1), port)));
  onoff.SetConstantRate (DataRate ("6Mb/s"));
  ApplicationContainer app = onoff.Install (nodes.Get (0));
  app.Start (Seconds (1.0));  app.Stop (Seconds (10.0));

  PacketSinkHelper sink ("ns3::TcpSocketFactory",
      Address (InetSocketAddress (Ipv4Address::GetAny (), port)));
  ApplicationContainer sinkApp = sink.Install (nodes.Get (1));
  sinkApp.Start (Seconds (0.0));

  pointToPoint.EnablePcapAll ("p2p");
  Simulator::Stop (Seconds (11.0));
  Simulator::Run ();

  Ptr<PacketSink> ps = DynamicCast<PacketSink> (sinkApp.Get (0));
  double throughput = (ps->GetTotalRx () * 8.0) / (9.0 * 1000000.0);
  std::cout << "Throughput : " << throughput << " Mbps" << std::endl;
  Simulator::Destroy ();
  return 0;
}

Formula used: Throughput (Mbps) = (total bytes received × 8) ÷ (sending time in seconds × 1,000,000). Run it four times with ./waf --run "p2p-throughput --delay=2ms", then 20ms, 100ms and 300ms.

Conclusion: the two-node network is built with PointToPointHelper, throughput is read from bytes received at the PacketSink, and higher latency gives lower TCP throughput because the sender waits longer for acknowledgements.

Sample 2 (Section A): Wireless MANET with OLSR Routing

Create a wireless mobile ad hoc network using three nodes. Install the Optimized Link State Routing (OLSR) protocol. Make necessary assumptions.

Assumptions: three nodes n1, n2, n3 using AdhocWifiMac with YansWifiPhy at a constant 6 Mbps; nodes start 40 m apart in a line and move slowly by random walk; OLSR is set before the stack is installed; n1 sends 5 echo packets to n3 from 20 s so OLSR has time to learn routes.

// Wi-Fi in ad hoc mode (no access point)
WifiMacHelper wifiMac;
wifiMac.SetType ("ns3::AdhocWifiMac");

// Mobility: start in a line, then random walk
mobility.SetMobilityModel ("ns3::RandomWalk2dMobilityModel",
    "Bounds", RectangleValue (Rectangle (-20, 200, -20, 20)),
    "Speed", StringValue ("ns3::ConstantRandomVariable[Constant=1.0]"));

// Install OLSR as the routing protocol
OlsrHelper olsr;
InternetStackHelper stack;
stack.SetRoutingHelper (olsr);   // takes effect on the next Install ()
stack.Install (nodes);

// Save routing tables of all nodes at 15 s
Ptr<OutputStreamWrapper> routes =
    Create<OutputStreamWrapper> ("olsr.routes", std::ios::out);
olsr.PrintRoutingTableAllAt (Seconds (15), routes);

Node: 0, Time: +15s, OLSR Routing table
Destination   NextHop    Interface   Distance
10.0.0.2      10.0.0.2   1           1
10.0.0.3      10.0.0.2   1           2

Observation: n1 reaches n2 in one hop, while n3 is out of direct range, so OLSR routes through n2 with a distance of 2. All five echo packets return, which proves multi-hop routing works. The full PDF includes the complete program, topology diagram and pcap step.

Sample 3 (Section A): UdpClient and UdpServer at a Fixed Data Rate

Create a UdpClient and UdpServer nodes and communicate at a fixed data rate. Make necessary assumptions.

Assumptions: n0 is the client and n1 the server on a 5 Mbps, 2 ms point-to-point link; the client sends one 1024-byte packet every 0.01 s from 2 s to 9 s; the server listens on port 4000. The fixed rate works out to 1024 × 8 ÷ 0.01 = 819,200 bits per second.

uint16_t port = 4000;
UdpServerHelper server (port);
ApplicationContainer serverApp = server.Install (nodes.Get (1));
serverApp.Start (Seconds (1.0));  serverApp.Stop (Seconds (10.0));

UdpClientHelper client (interfaces.GetAddress (1), port);
client.SetAttribute ("MaxPackets", UintegerValue (1000));
client.SetAttribute ("Interval", TimeValue (Seconds (0.01)));
client.SetAttribute ("PacketSize", UintegerValue (1024));
ApplicationContainer clientApp = client.Install (nodes.Get (0));
clientApp.Start (Seconds (2.0));  clientApp.Stop (Seconds (9.0));

Output: packets received at server 700, packets lost 0. The client ran for 7 seconds at 100 packets per second, and the 5 Mbps link is faster than the sending rate, so nothing is dropped.

Sample 4 (Section B): J48 Classification with Confusion Matrix

Perform classification on any dataset using the J48 algorithm in WEKA toolkit. Show the confusion matrix and accuracy. Make necessary assumptions.

Steps in WEKA Explorer: open the GUI Chooser and click Explorer, load iris.arff in the Preprocess tab, open the Classify tab, choose trees then J48, keep 10-fold cross-validation, click Start, then right-click the result list and pick Visualize Tree. J48 is WEKA's name for the C4.5 decision tree.

Reading it: rows are actual classes and columns are predictions. The diagonal (49 + 47 + 48) gives 144 correct out of 150, so accuracy = 144 ÷ 150 × 100 = 96%. Most of the 6 errors fall between versicolor and virginica, whose petal sizes overlap.

Sample 5 (Section B): Simple K-Means Clustering in WEKA

Implement the Simple K-Means algorithm to demonstrate the clustering process on a dataset. Observe the sum of squared errors and the clusters formed, and visualize the clusters.

How K-Means works: choose K, assign each point to the nearest centre, recompute each centroid as the mean of its points, recheck Euclidean distances and move misplaced points, then repeat until no assignment changes. In WEKA: load vote.arff, open the Cluster tab, choose SimpleKMeans, set K to 6 with Euclidean distance, click Start, then rerun with Classes to Clusters evaluation.

Observation: cluster 0 lines up with republican votes and cluster 3 with democrat votes. Raising K lowers the SSE, and ignoring weak attributes brings the 39.77% error down. In the Visualize tab, pushing Jitter to maximum separates overlapping nominal points.